jcal-zmanim 1.0.4

package/src/JCal/Dafyomi.ts

@@ -0,0 +1,139 @@
+import Utils from './Utils.js';
+import jDate from './jDate.js';
+
+'use strict';
+/** *********************************************************************************************************
+ * Computes the Day Yomi for the given day.
+ * Sample of use - to get todays daf:
+ *     const dafEng = Dafyomi.toString(new jDate(new Date()));
+ *     const dafHeb = Dafyomi.toStringHeb(new jDate(new Date()));
+ * The code was converted to javascript and tweaked by CBS.
+ * It is directly based on the C code in Danny Sadinoff's HebCal - Copyright (C) 1994.
+ * The HebCal code for dafyomi was adapted by Aaron Peromsik from Bob Newell's public domain daf.el.
+***********************************************************************************************************/
+export default class Dafyomi {
+    static masechtaList = [
+        { eng: 'Berachos', heb: 'ברכות', daf: 64 },
+        { eng: 'Shabbos', heb: 'שבת', daf: 157 },
+        { eng: 'Eruvin', heb: 'ערובין', daf: 105 },
+        { eng: 'Pesachim', heb: 'פסחים', daf: 121 },
+        { eng: 'Shekalim', heb: 'שקלים', daf: 22 },
+        { eng: 'Yoma', heb: 'יומא', daf: 88 },
+        { eng: 'Sukkah', heb: 'סוכה', daf: 56 },
+        { eng: 'Beitzah', heb: 'ביצה', daf: 40 },
+        { eng: 'Rosh Hashana', heb: 'ראש השנה', daf: 35 },
+        { eng: 'Taanis', heb: 'תענית', daf: 31 },
+        { eng: 'Megillah', heb: 'מגילה', daf: 32 },
+        { eng: 'Moed Katan', heb: 'מועד קטן', daf: 29 },
+        { eng: 'Chagigah', heb: 'חגיגה', daf: 27 },
+        { eng: 'Yevamos', heb: 'יבמות', daf: 122 },
+        { eng: 'Kesubos', heb: 'כתובות', daf: 112 },
+        { eng: 'Nedarim', heb: 'נדרים', daf: 91 },
+        { eng: 'Nazir', heb: 'נזיר', daf: 66 },
+        { eng: 'Sotah', heb: 'סוטה', daf: 49 },
+        { eng: 'Gitin', heb: 'גיטין', daf: 90 },
+        { eng: 'Kiddushin', heb: 'קדושין', daf: 82 },
+        { eng: 'Baba Kamma', heb: 'בבא קמא', daf: 119 },
+        { eng: 'Baba Metzia', heb: 'בבא מציעא', daf: 119 },
+        { eng: 'Baba Basra', heb: 'בבא בתרא', daf: 176 },
+        { eng: 'Sanhedrin', heb: 'סנהדרין', daf: 113 },
+        { eng: 'Makkot', heb: 'מכות', daf: 24 },
+        { eng: 'Shevuot', heb: 'שבועות', daf: 49 },
+        { eng: 'Avodah Zarah', heb: 'עבודה זרה', daf: 76 },
+        { eng: 'Horayot', heb: 'הוריות', daf: 14 },
+        { eng: 'Zevachim', heb: 'זבחים', daf: 120 },
+        { eng: 'Menachos', heb: 'מנחות', daf: 110 },
+        { eng: 'Chullin', heb: 'חולין', daf: 142 },
+        { eng: 'Bechoros', heb: 'בכורות', daf: 61 },
+        { eng: 'Arachin', heb: 'ערכין', daf: 34 },
+        { eng: 'Temurah', heb: 'תמורה', daf: 34 },
+        { eng: 'Kerisos', heb: 'כריתות', daf: 28 },
+        { eng: 'Meilah', heb: 'מעילה', daf: 22 },
+        { eng: 'Kinnim', heb: 'קנים', daf: 4 },
+        { eng: 'Tamid', heb: 'תמיד', daf: 10 },
+        { eng: 'Midos', heb: 'מדות', daf: 4 },
+        { eng: 'Niddah', heb: 'נדה', daf: 73 }];
+
+    static getDaf(jdate:jDate) : {
+        masechet:  { eng: string, heb: string, daf: number },
+        daf: number
+    } | null{
+        const absoluteDate = jdate.Abs;
+        let dafcnt = 40, cno:number, dno:number, osday:number, nsday:number, total:number, count:number, j:number, blatt:number;
+
+        osday = jDate.absSd(new Date(1923, 8, 11));
+        nsday = jDate.absSd(new Date(1975, 5, 24));
+
+        /*  No cycle, new cycle, old cycle */
+        if (absoluteDate < osday)
+            return null; /* daf yomi hadn't started yet */
+        if (absoluteDate >= nsday) {
+            cno = 8 + Utils.toInt(((absoluteDate - nsday) / 2711));
+            dno = (absoluteDate - nsday) % 2711;
+        }
+        else {
+            cno = 1 + Utils.toInt((absoluteDate - osday) / 2702);
+            dno = Utils.toInt((absoluteDate - osday) / 2702);
+        }
+
+        /* Find the daf taking note that the cycle changed slightly after cycle 7. */
+        total = blatt = 0;
+        count = -1;
+
+        /* Fix Shekalim for old cycles */
+        if (cno <= 7)
+            Dafyomi.masechtaList[4].daf = 13;
+        else
+            Dafyomi.masechtaList[4].daf = 22;
+
+        /* Find the daf */
+        j = 0;
+        while (j < dafcnt) {
+            count++;
+            total = total + Dafyomi.masechtaList[j].daf - 1;
+            if (dno < total) {
+                blatt = (Dafyomi.masechtaList[j].daf + 1) - (total - dno);
+                /* fiddle with the weird ones near the end */
+                switch (count) {
+                    case 36:
+                        blatt = blatt + 21;
+                        break;
+                    case 37:
+                        blatt = blatt + 24;
+                        break;
+                    case 38:
+                        blatt = blatt + 33;
+                        break;
+                    default:
+                        break;
+                }
+                /* Bailout */
+                j = 1 + dafcnt;
+            }
+            j++;
+        }
+
+        return {
+            masechet: Dafyomi.masechtaList[count],
+            daf: blatt
+        };
+    }
+
+    // Returns the name of the Masechta and daf number in English, For example: Sukkah, Daf 3
+    static toString(jd:jDate):string|undefined {
+        const d = Dafyomi.getDaf(jd);
+        if(d!==null)
+        {
+        return d.masechet.eng + ', Daf ' + d.daf.toString();
+        }
+    }
+
+    //Returns the name of the Masechta and daf number in Hebrew. For example: 'סוכה דף כ.
+    static toStringHeb(jd:jDate):string |undefined{
+        const d = Dafyomi.getDaf(jd);
+        if(d!==null)
+        {
+        return d.masechet.heb + ' דף ' + Utils.toJNum(d.daf);
+        }
+    }
+}

package/src/JCal/Location.ts

@@ -0,0 +1,100 @@
+/** Represents a geographic Location. Needed for calculating Zmanim.
+If Israel is undefined, if the given coordinates are near the vicinity of Israel it will be assumed that it is in Israel.
+UTCOffset is the time zone. Israel is always 2 and the US East coast is -5. England is 0 of course.
+If UTCOffset is not specifically supplied, the longitude will be used to get a quasi-educated guess.*/
+export default class Location {
+    Name: string;
+    Israel: boolean;
+    Latitude: number;
+    Longitude: number;
+    UTCOffset: number;
+    Elevation: number;
+    CandleLighting?: number;
+    locationId?: number;
+    /**
+     * Describe a new Location.
+     * @param {String} name The name of the Location
+     * @param {Boolean} israel Is this Location in Israel?
+     * @param {Number} latitude
+     * @param {Number} longitude
+     * @param {Number} utcOffset The time zone. Israel is 2 and New York is -5.
+     * @param {Number} elevation Elevation in meters
+     * @param {Number} [candleLighting] Number of minutes before sunset the candles are lit on Friday
+     * @param {Number} [locationId] If this location is in a database, keeps track of the id
+     */
+    constructor(name:string, israel:boolean, latitude:number, longitude:number, utcOffset:number, elevation:number, candleLighting?:number, locationId?:number) {
+        //If the israel argument was not set at all.
+        if (typeof israel === 'undefined' || israel === null) {
+            //If the user is within Israels general coordinates,
+            //we feel pretty safe assuming they are in Israel.
+            //Where else on the map is the user? (Note, the probablity of our users Jewishness: 99.99%)
+            //Sinai, Lebanon, Syria, Jordan, in a submarine under the Mediterannian ...
+            israel = (latitude > 29.45 && latitude < 33 && longitude < -34.23 && longitude > -35.9);
+        }
+        if (israel) {
+            //Israel has only one immutable time zone
+            utcOffset = 2;
+        }
+        //If the utcOffset argument was not set at all.
+        else if (typeof utcOffset === 'undefined' || utcOffset === null) {
+            //Try to determine the "correct" time zone using the simple fact that Greenwich is both TZ 0 and longitude 0.
+            //Even though technically this is the way it should be,
+            //it will be often incorrect as time zones are almost always tweaked to accomadate the closest border.
+            utcOffset = -Math.round(longitude / 15);
+        }
+
+        this.Name = (name || 'Unknown Location');
+        this.Israel = !!israel;
+        this.Latitude = latitude;
+        this.Longitude = longitude;
+        this.UTCOffset = utcOffset || 0;
+        this.Elevation = elevation || 0;
+        this.CandleLighting = candleLighting || Location.getCandles(this);
+        this.locationId = locationId;
+    }
+
+    hasId() {
+        return !!this.locationId;
+    }
+
+    static clone(location:Location) {
+        return new Location(
+            location.Name,
+            location.Israel,
+            location.Latitude,
+            location.Longitude,
+            location.UTCOffset,
+            location.Elevation,
+            location.CandleLighting || 0,
+            location.locationId||0);
+    }
+
+    static getCandles(location:Location) {
+        if (location.CandleLighting) {
+            return location.CandleLighting;
+        }
+        else if (!location.Israel) {
+            return 18;
+        }
+        else {
+            const special = [{ names: ['jerusalem', 'yerush', 'petach', 'petah', 'petak', 'beit shemesh', 'ירושלים', 'פתח תקוה', 'בית שמש'], min: 40 },
+            { names: ['haifa', 'chaifa', 'be\'er sheva', 'beersheba', 'חיפה', 'באר שבע'], min: 22 }],
+                loclc = location.Name.toLowerCase(),
+                city = special.find(sp => {
+                    return sp.names.find(spi => {
+                        return loclc.indexOf(spi) > -1;
+                    });
+                });
+            return city ? city.min : 30;
+        }
+    }
+
+    /**Gets the Location for Jerusalem.*/
+    static getJerusalem() {
+        return new Location('Jerusalem', true, 31.78, -35.22, 2, 800, 40, 28);
+    }
+    /**Gets the Location for Lakewood NJ*/
+    static getLakewood() {
+        return new Location('Lakewood NJ', false, 40.1, 74.23, -5, 0, 18, 185);
+    }
+}

package/src/JCal/Molad.ts

@@ -0,0 +1,105 @@
+import Utils from './Utils.js';
+import jDate from './jDate.js';
+import Location from './Location.js';
+import { Time } from '../jcal-zmanim.js';
+
+/**
+ * Gets the molad for the given jewish month and year.
+ * Algorithm was adapted from Hebcal by Danny Sadinoff
+ *
+ * Example of use:
+ * const moladString = Molad.getString(5776, 10);
+ */
+export default class Molad {    
+    /**
+     *
+     * @param {Number} month
+     * @param {Number} year
+     * @returns {{jDate:jDate,time:Time,chalakim:number}}
+     */
+    static getMolad(month:number, year:number) :{jDate:jDate,time:Time,chalakim:number} {
+        let totalMonths, partsElapsed, hoursElapsed, parts, monthAdj = month - 7;
+
+        if (monthAdj < 0) {
+            monthAdj += jDate.monthsJYear(year);
+        }
+        totalMonths = Utils.toInt(monthAdj + 235 * Utils.toInt((year - 1) / 19) + 12 * ((year - 1) % 19) +
+            ((((year - 1) % 19) * 7) + 1) / 19);
+        partsElapsed = 204 + (793 * (totalMonths % 1080));
+        hoursElapsed = 5 + (12 * totalMonths) + 793 * Utils.toInt(totalMonths / 1080) +
+            Utils.toInt(partsElapsed / 1080) - 6;
+        parts = Utils.toInt((partsElapsed % 1080) + 1080 * (hoursElapsed % 24));
+
+        return {
+            jDate: new jDate((1 + (29 * Utils.toInt(totalMonths))) + Utils.toInt((hoursElapsed / 24))),
+            time: { hour: Utils.toInt(hoursElapsed) % 24, minute: Utils.toInt((parts % 1080) / 18), second: 0 },
+            chalakim: parts % 18
+        };
+    }
+
+    /**
+     * Returns the time of the molad as a string in the format: Monday Night, 8:33 PM and 12 Chalakim
+     * The molad is always in Jerusalem so we use the Jerusalem sunset times
+     * to determine whether to display "Night" or "Motzai Shabbos" etc. (check this...)
+     * @param {Number} year
+     * @param {Number} month
+     */
+    static getString(year:number, month:number):string {
+        const molad = Molad.getMolad(month, year),
+            zmanim = molad.jDate.getSunriseSunset(Location.getJerusalem()),
+            isNight = Utils.isTimeAfter(zmanim.sunset, molad.time),
+            dow = molad.jDate.getDayOfWeek();
+        let str = '';
+
+        if (!zmanim.sunset || isNaN(zmanim.sunset.hour)) {
+            str += Utils.dowEng[dow];
+        }
+        else if (dow === 6 && isNight) {
+            str += 'Motzai Shabbos,';
+        }
+        else if (dow === 5 && isNight) {
+            str += 'Shabbos Night,';
+        }
+        else {
+            str += Utils.dowEng[dow] + (isNight ? ' Night' : '');
+        }
+        str += ' ' + Utils.getTimeString(molad.time) + ' and ' +
+            molad.chalakim.toString() + ' Chalakim';
+
+        return str;
+    }
+    time(sunset: any, time: any) {
+        throw new Error('Method not implemented.');
+    }
+
+    /**
+     * Returns the time of the molad as a string in the format: ליל שני 20:33 12 חלקים
+     * The molad is always in Jerusalem so we use the Jerusalem sunset times
+     * to determine whether to display "ליל/יום" or "מוצאי שב"ק" etc.
+     * @param {Number} year
+     * @param {Number} month
+     */
+    static getStringHeb(year:number, month:number):string {
+        const molad = Molad.getMolad(month, year),
+            zmanim = molad.jDate.getSunriseSunset(Location.getJerusalem()),
+            isNight = Utils.isTimeAfter(zmanim.sunset, molad.time) &&
+                Utils.isTimeAfter(molad.time, zmanim.sunrise),
+            dow = molad.jDate.getDayOfWeek();
+        let str = '';
+
+        if (dow === 6) {
+            str += (isNight ? 'מוצאי שב"ק' : 'יום שב"ק');
+        }
+        else if (dow === 5) {
+            str += (isNight ? 'ליל שב"ק' : 'ערב שב"ק');
+        }
+        else {
+            str += (isNight ? 'ליל' : 'יום') +
+                Utils.dowHeb[dow].replace('יום', '');
+        }
+        str += ' ' + Utils.getTimeString(molad.time,1, true) + ' ' +
+            molad.chalakim.toString() + ' חלקים';
+
+        return str;
+    }
+}

package/src/JCal/PirkeiAvos.ts

@@ -0,0 +1,180 @@
+import jDate from './jDate.js';
+import Utils from './Utils.js';
+
+'use strict';
+
+/****************************************************************************************************************
+ * Computes the Perek/Prakim of the week for the given Shabbos.
+ * Returns an array of prakim (integers) (either one or two) for the given Jewish Date
+ * Sample of use to get todays sedra in Israel:
+ *     const prakim = PirkeiAvos.getPrakim(new jDate(), true);
+ *     const str = 'Pirkei Avos: ' + prakim.map(s => `${Utils.toSuffixed(s)} Perek`).join(' and ');
+ * ***************************************************************************************************************/
+export default class PirkeiAvos {
+    static getPrakim(jd:jDate, israel:boolean) {
+        if (jd.getDayOfWeek() !== 6) {
+            return [];
+        }
+
+        const jMonth = jd.Month,
+            jDay = jd.Day;
+
+        //Pirkei Avos is from after Pesach until Rosh Hashana
+        if ((jMonth === 1 && jDay > (israel ? 21 : 22)) ||
+            //All Shabbosim through Iyar, Sivan, Tamuz, Av - besides for the day/s of Shavuos and Tisha B'Av
+            ((jMonth > 1 && jMonth < 6 &&
+                (!((jMonth === 3 && jDay === 6) || (!israel && jMonth === 3 && jDay === 7))) &&
+                (!(jMonth === 5 && jDay === 9))))) {
+            return [PirkeiAvos._get1stPerek(jd, israel)];
+        }
+        //Ellul can have multiple prakim
+        else if (jMonth === 6) {
+            return PirkeiAvos._ellul(jd, israel);
+        }
+        //No Pirkei Avos
+        else {
+            return [];
+        }
+    }
+    static _get1stPerek = function (jd:jDate, israel:boolean) {
+        const jYear = jd.Year,
+            jMonth = jd.Month,
+            jDay = jd.Day,
+            pes1 = new jDate(jYear, 1, 15),
+            //How many days after the first day of pesach was the first shabbos after pesach
+            shb1 = (israel ? 7 : 8) + (6 - pes1.getDayOfWeek()),
+            //What number shabbos after pesach is the current date
+            cShb = ((jMonth === 1 && jDay === (shb1 + 15)) ? 1 :
+                Utils.toInt((jd.Abs - (pes1.Abs + shb1)) / 7) + 1);
+        let prk = cShb % 6;
+        if (prk === 0) prk = 6;
+        //If the second day of Shavuos was on Shabbos, we missed a week.
+        //The second day of Pesach is always the same day as the first day of Shavuos.
+        //So if Pesach was on Thursday, Shavuos will be on Friday and Shabbos in Chu"l.
+        //Pesach can never come out on Friday, so in E. Yisroel Shavuos is never on Shabbos.
+        if ((!israel) && pes1.getDayOfWeek() === 4 && (jMonth > 3 || (jMonth === 3 && jDay > 6))) {
+            prk = prk === 1 ? 6 : prk - 1;
+        }
+        //If Tisha B'Av was on Shabbos, we missed a week. The first day of Pesach is always the same day of the week as Tisha b'av.
+        if (pes1.getDayOfWeek() === 6 && (jMonth > 5 || (jMonth === 5 && jDay > 9))) {
+            prk = prk === 1 ? 6 : prk - 1;
+        }
+
+        return prk;
+    }
+    static _ellul = function (jd:jDate, israel:boolean) {
+        let prakim;
+        const jYear = jd.Year,
+            jDay = jd.Day,
+            //The fist day of Ellul.
+            //The year/month/day/absoluteDay constructor for JDate is used for efficiency.
+            day1 = new jDate(jYear, 6, 1, jd.Abs - jd.Day + 1),
+            day1DOW = day1.getDayOfWeek(),
+            shabbos1Day = day1DOW === 6 ? 1 : ((6 - (day1DOW + 6) % 6) + 1),
+            shabbos1Date = new jDate(jYear, 6, shabbos1Day, day1.Abs + shabbos1Day - 1),
+            //Which shabbos in Ellul are we working out now?
+            cShb = jDay === shabbos1Day ? 1 : Utils.toInt((jDay - shabbos1Day) / 7) + 1;
+
+        switch (PirkeiAvos._get1stPerek(shabbos1Date, israel)) {
+            case 1:
+                switch (cShb) {
+                    case 1:
+                        prakim = [1];
+                        break;
+                    case 2:
+                        prakim = [2];
+                        break;
+                    case 3:
+                        prakim = [3, 4];
+                        break;
+                    case 4:
+                        prakim = [5, 6];
+                        break;
+                }
+                break;
+            case 2:
+                switch (cShb) {
+                    case 1:
+                        prakim = [2];
+                        break;
+                    case 2:
+                        prakim = [3];
+                        break;
+                    case 3:
+                        prakim = [4];
+                        break;
+                    case 4:
+                        prakim = [5, 6];
+                        break;
+                }
+                break;
+            case 3:
+                switch (cShb) {
+                    case 1:
+                        prakim = [3];
+                        break;
+                    case 2:
+                        prakim = [4];
+                        break;
+                    case 3:
+                        prakim = [5];
+                        break;
+                    case 4:
+                        prakim = [6];
+                        break;
+                }
+                break;
+            case 4:
+                //This can only happen in Chutz La'aretz
+                switch (cShb) {
+                    case 1:
+                        prakim = [4, 5];
+                        break;
+                    case 2:
+                        prakim = [6, 1];
+                        break;
+                    case 3:
+                        prakim = [2, 3];
+                        break;
+                    case 4:
+                        prakim = [4, 5, 6];
+                        break;
+                }
+                break;
+            case 5:
+                switch (cShb) {
+                    case 1:
+                        prakim = [5, 6];
+                        break;
+                    case 2:
+                        prakim = [1, 2];
+                        break;
+                    case 3:
+                        prakim = [3, 4];
+                        break;
+                    case 4:
+                        prakim = [5, 6];
+                        break;
+                }
+                break;
+            case 6:
+                switch (cShb) {
+                    case 1:
+                        prakim = [6];
+                        break;
+                    case 2:
+                        prakim = [1, 2];
+                        break;
+                    case 3:
+                        prakim = [3, 4];
+                        break;
+                    case 4:
+                        prakim = [5, 6];
+                        break;
+                }
+                break;
+        }
+
+        return prakim || [];
+    }
+}