jcal-zmanim 1.0.4

package/build/AppUtils.d.ts

@@ -0,0 +1,109 @@
+import Location from './JCal/Location';
+import Settings from './Settings';
+import jDate from './JCal/jDate';
+import { SunTimes, Time, ZmanToShow } from './jcal-zmanim';
+type ZmanTime = {
+    date: Date;
+    location: Location;
+    sunrise: Time | undefined;
+    sunset: Time | undefined;
+    suntimesMishor: SunTimes | undefined;
+    sunriseMishor: Time | undefined;
+    sunsetMishor: Time | undefined;
+    mishorNeg90: Time | undefined;
+    chatzos: Time | undefined;
+    shaaZmanis: number | undefined;
+    shaaZmanisMga: number | undefined;
+};
+export declare const DaysOfWeek: Readonly<{
+    SUNDAY: 0;
+    MONDAY: 1;
+    TUESDAY: 2;
+    WEDNESDAY: 3;
+    THURSDAY: 4;
+    FRIDAY: 5;
+    SHABBOS: 6;
+}>;
+export declare const WhichDaysFlags: Readonly<{
+    SUNDAY: 1;
+    MONDAY: 2;
+    TUESDAY: 4;
+    WEDNESDAY: 8;
+    THURSDAY: 16;
+    FRIDAY: 32;
+    SHABBOS: 64;
+    YOMTOV: 128;
+}>;
+export default class AppUtils {
+    static zmanTimesCache: ZmanTime[];
+    /**
+     * Returns the date corrected time of the given zmanim on the given date at the given location
+     * If the zman is after or within 30 minutes of the given time, this days zman is returned, othwise tomorrows zman is returned.
+     * @param {Date} sdate
+     * @param {jDate} jdate
+     * @param {Time} time
+     * @param {Settings} settings
+     * @param {Time} sunset
+     * @returns {[{zmanType:ZmanToShow,time:Time, isTomorrow:boolean}]}
+     */
+    static getCorrectZmanTimes(sdate: Date, jdate: jDate, time: Time, settings: Settings, sunset: Time): {
+        zmanType: ZmanToShow;
+        time: Time;
+        isTomorrow: boolean;
+    }[];
+    /**
+     * Gets the zmanim for all the types in the given list.
+     * @param {[ZmanToShow]} zmanTypes An array of ZmanTypes to get the zman for.
+     * @param {Date} date The secular date to get the zmanim for
+     * @param {jDate} jdate The jewish date to get the zmanim for
+     * @param {Location} location The location for which to get the zmanim
+     * @returns{[{zmanType:{id:number,offset:?number,desc:string,eng:string,heb:string },time:Time}]}
+     */
+    static getZmanTimes(zmanTypes: ZmanToShow[], date: Date, jdate: jDate, location: Location): {
+        zmanType: ZmanToShow;
+        time?: Time;
+    }[];
+    /**
+     * Get the WhichDaysFlags for the given secular date
+     * @param {Date} date
+     * @param {jDate} jdate
+     * @param {Location} location
+     */
+    static getWhichDays(date: Date, jdate: jDate, location: Location): 1 | 0 | 2 | 4 | 8 | 16 | 32 | 64 | 128;
+    /**
+     * Returns the zmanim necessary for showing basic shul notifications: chatzosHayom, chatzosHalayla, alos
+     * @param {jDate} jdate
+     * @param {Date} sdate
+     * @param {Location} location
+     * @returns {{chatzosHayom:Time, chatzosHalayla:Time, alos:Time, shkia:Time }}
+     */
+    static getBasicShulZmanim(jdate: jDate, sdate: Date, location: Location): {
+        chatzosHayom: Time | undefined;
+        chatzosHalayla: Time | undefined;
+        alos: Time | undefined;
+        shkia: Time | undefined;
+    };
+    /**
+    * Returns all the zmanim for the given day
+    * @param {jDate} jdate
+    * @param {Date} sdate
+    * @param {Location} location
+    * @returns {{zmanType:ZmanToShow, time?:Time }[]}
+    */
+    static getAllZmanim(jdate: jDate, sdate: Date, location: Location): {
+        zmanType: ZmanToShow;
+        time?: Time | undefined;
+    }[];
+    /**
+     * Compares two zmanim for showing to see if they are the same
+     * @param {{id:number,offset:?Number, whichDaysFlags:?Number, desc: String, eng: String, heb: String }} zman1
+     * @param {{id:number,offset:?Number, whichDaysFlags:?Number, desc: String, eng: String, heb: String }} zman2
+     */
+    static IsSameZmanToShow(zman1: ZmanToShow, zman2: ZmanToShow): boolean;
+    /**
+     * Returns all available ZmanTypes - including baseTypes and custom added types
+     * @param {Settings} settings
+     */
+    static AllZmanTypes(settings: Settings): ZmanToShow[];
+}
+export {};

package/build/AppUtils.js

@@ -0,0 +1,394 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhichDaysFlags = exports.DaysOfWeek = void 0;
+const Utils_1 = __importDefault(require("./JCal/Utils"));
+const Zmanim_1 = __importDefault(require("./JCal/Zmanim"));
+const ZmanTypes_1 = require("./ZmanTypes");
+exports.DaysOfWeek = Object.freeze({
+    SUNDAY: 0,
+    MONDAY: 1,
+    TUESDAY: 2,
+    WEDNESDAY: 3,
+    THURSDAY: 4,
+    FRIDAY: 5,
+    SHABBOS: 6,
+});
+exports.WhichDaysFlags = Object.freeze({
+    SUNDAY: 1,
+    MONDAY: 2,
+    TUESDAY: 4,
+    WEDNESDAY: 8,
+    THURSDAY: 16,
+    FRIDAY: 32,
+    SHABBOS: 64,
+    YOMTOV: 128,
+});
+class AppUtils {
+    /**
+     * Returns the date corrected time of the given zmanim on the given date at the given location
+     * If the zman is after or within 30 minutes of the given time, this days zman is returned, othwise tomorrows zman is returned.
+     * @param {Date} sdate
+     * @param {jDate} jdate
+     * @param {Time} time
+     * @param {Settings} settings
+     * @param {Time} sunset
+     * @returns {[{zmanType:ZmanToShow,time:Time, isTomorrow:boolean}]}
+     */
+    static getCorrectZmanTimes(sdate, jdate, time, settings, sunset) {
+        const correctedTimes = [], zmanTypes = settings.zmanimToShow, location = settings.location, tomorrowJd = jdate.addDays(1), tomorrowSd = Utils_1.default.addDaysToSdate(sdate, 1), 
+        /*  Candle lighting and chometz times are not shown after sunset.
+            This solves the issue of Candle lighting showing as having "passed 20 minutes ago"
+            Thursday evening after sunset - which shows as hasCandleLighting = true
+            as it is already Friday... */
+        zmanTimes = AppUtils.getZmanTimes(zmanTypes.filter((zt) => ![21, 22, 23].includes(zt.id) || Utils_1.default.isTimeAfter(time, sunset)), sdate, jdate, location), tomorrowTimes = AppUtils.getZmanTimes(
+        //Candle lighting tomorrow is never shown...
+        zmanTypes.filter((zt) => zt.id !== 21), tomorrowSd, tomorrowJd, location);
+        for (let zt of zmanTimes) {
+            let oTime = zt.time, isTomorrow = false, diff = Utils_1.default.timeDiff(time, oTime, true);
+            if (diff.sign < 1 &&
+                Utils_1.default.totalMinutes(diff) >= settings.minToShowPassedZman) {
+                const tom = tomorrowTimes.find((t) => t.zmanType === zt.zmanType);
+                if (tom && tom.time) {
+                    oTime = tom.time;
+                    isTomorrow = true;
+                }
+            }
+            correctedTimes.push({
+                zmanType: zt.zmanType,
+                time: oTime,
+                isTomorrow,
+            });
+        }
+        return correctedTimes.sort((a, b) => (a.isTomorrow ? 1 : -1) - (b.isTomorrow ? 1 : -1) ||
+            Utils_1.default.totalSeconds(a.time) - Utils_1.default.totalSeconds(b.time));
+    }
+    /**
+     * Gets the zmanim for all the types in the given list.
+     * @param {[ZmanToShow]} zmanTypes An array of ZmanTypes to get the zman for.
+     * @param {Date} date The secular date to get the zmanim for
+     * @param {jDate} jdate The jewish date to get the zmanim for
+     * @param {Location} location The location for which to get the zmanim
+     * @returns{[{zmanType:{id:number,offset:?number,desc:string,eng:string,heb:string },time:Time}]}
+     */
+    static getZmanTimes(zmanTypes, date, jdate, location) {
+        const mem = AppUtils.zmanTimesCache.find((z) => Utils_1.default.isSameSdate(z.date, date) &&
+            z.location.Name === location.Name), zmanTimes = [], whichDay = AppUtils.getWhichDays(date, jdate, location);
+        let sunrise, sunset, suntimesMishor, sunriseMishor, sunsetMishor, mishorNeg90, chatzos, shaaZmanis, shaaZmanisMga;
+        if (mem) {
+            sunrise = mem.sunrise;
+            sunset = mem.sunset;
+            suntimesMishor = mem.suntimesMishor;
+            sunriseMishor = mem.sunriseMishor;
+            sunsetMishor = mem.sunsetMishor;
+            mishorNeg90 = mem.mishorNeg90;
+            chatzos = mem.chatzos;
+            shaaZmanis = mem.shaaZmanis;
+            shaaZmanisMga = mem.shaaZmanisMga;
+        }
+        else {
+            const suntimes = Zmanim_1.default.getSunTimes(date, location, true);
+            sunrise = suntimes.sunrise;
+            sunset = suntimes.sunset;
+            suntimesMishor = Zmanim_1.default.getSunTimes(date, location, false);
+            sunriseMishor = suntimesMishor.sunrise;
+            sunsetMishor = suntimesMishor.sunset;
+            mishorNeg90 = Utils_1.default.addMinutes(sunriseMishor, -90);
+            chatzos =
+                sunriseMishor &&
+                    sunsetMishor &&
+                    Zmanim_1.default.getChatzosFromSuntimes(suntimesMishor);
+            shaaZmanis =
+                sunriseMishor &&
+                    sunsetMishor &&
+                    Zmanim_1.default.getShaaZmanisFromSunTimes(suntimesMishor);
+            shaaZmanisMga =
+                sunriseMishor &&
+                    sunsetMishor &&
+                    Zmanim_1.default.getShaaZmanisMga(suntimesMishor, true);
+            AppUtils.zmanTimesCache.push({
+                date,
+                location,
+                sunrise,
+                sunset,
+                suntimesMishor,
+                sunriseMishor,
+                sunsetMishor,
+                mishorNeg90,
+                chatzos,
+                shaaZmanis,
+                shaaZmanisMga,
+            });
+        }
+        for (let zmanType of zmanTypes) {
+            const offset = zmanType.offset &&
+                (!zmanType.whichDaysFlags || zmanType.whichDaysFlags & whichDay)
+                ? zmanType.offset
+                : 0;
+            switch (zmanType.id) {
+                case ZmanTypes_1.ZmanTypeIds.ChatzosLayla: // chatzosNight
+                    zmanTimes.push({
+                        zmanType,
+                        time: Utils_1.default.addMinutes(chatzos, 720 + offset),
+                    });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.Alos90: // alos90
+                    zmanTimes.push({
+                        zmanType,
+                        time: offset
+                            ? Utils_1.default.addMinutes(mishorNeg90, offset)
+                            : mishorNeg90,
+                    });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.Alos72: // alos72
+                    zmanTimes.push({
+                        zmanType,
+                        time: Utils_1.default.addMinutes(sunriseMishor, -72 + offset),
+                    });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.TalisTefillin: //talisTefillin
+                    zmanTimes.push({
+                        zmanType,
+                        time: Utils_1.default.addMinutes(sunriseMishor, -36 + offset),
+                    });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.NetzAtElevation: //netzElevation
+                    zmanTimes.push({
+                        zmanType,
+                        time: offset
+                            ? Utils_1.default.addMinutes(sunrise, offset)
+                            : sunrise,
+                    });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.NetzMishor: // netzMishor:
+                    zmanTimes.push({
+                        zmanType,
+                        time: offset
+                            ? Utils_1.default.addMinutes(sunriseMishor, offset)
+                            : sunriseMishor,
+                    });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.szksMga: //szksMga
+                    if (shaaZmanisMga)
+                        zmanTimes.push({
+                            zmanType,
+                            time: Utils_1.default.addMinutes(mishorNeg90, Math.floor(shaaZmanisMga * 3) + offset),
+                        });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.szksGra: //szksGra
+                    if (shaaZmanis)
+                        zmanTimes.push({
+                            zmanType,
+                            time: Utils_1.default.addMinutes(sunriseMishor, Math.floor(shaaZmanis * 3) + offset),
+                        });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.sztMga: // sztMga
+                    if (shaaZmanisMga)
+                        zmanTimes.push({
+                            zmanType,
+                            time: Utils_1.default.addMinutes(mishorNeg90, Math.floor(shaaZmanisMga * 4) + offset),
+                        });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.sztGra: //sztGra
+                    if (shaaZmanis)
+                        zmanTimes.push({
+                            zmanType,
+                            time: Utils_1.default.addMinutes(sunriseMishor, Math.floor(shaaZmanis * 4) + offset),
+                        });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.chatzosDay: //chatzos
+                    zmanTimes.push({
+                        zmanType,
+                        time: offset
+                            ? Utils_1.default.addMinutes(chatzos, offset)
+                            : chatzos,
+                    });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.minGed: //minGed
+                    if (shaaZmanis)
+                        zmanTimes.push({
+                            zmanType,
+                            time: Utils_1.default.addMinutes(chatzos, shaaZmanis * 0.5 + offset),
+                        });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.minKet: //minKet
+                    if (shaaZmanis)
+                        zmanTimes.push({
+                            zmanType,
+                            time: Utils_1.default.addMinutes(sunriseMishor, shaaZmanis * 9.5 + offset),
+                        });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.plag: //plag
+                    if (shaaZmanis)
+                        zmanTimes.push({
+                            zmanType,
+                            time: Utils_1.default.addMinutes(sunriseMishor, shaaZmanis * 10.75 + offset),
+                        });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.shkiaAtSeaLevel: //shkiaMishor
+                    zmanTimes.push({
+                        zmanType,
+                        time: offset
+                            ? Utils_1.default.addMinutes(sunsetMishor, offset)
+                            : sunsetMishor,
+                    });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.shkiaElevation: //shkiaElevation
+                    zmanTimes.push({
+                        zmanType,
+                        time: offset
+                            ? Utils_1.default.addMinutes(sunset, offset)
+                            : sunset,
+                    });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.tzais45: // tzais45
+                    zmanTimes.push({
+                        zmanType,
+                        time: Utils_1.default.addMinutes(sunset, 45 + offset),
+                    });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.tzais50: //tzais50
+                    zmanTimes.push({
+                        zmanType,
+                        time: Utils_1.default.addMinutes(sunset, 50 + offset),
+                    });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.tzais72: //tzais72
+                    zmanTimes.push({
+                        zmanType,
+                        time: Utils_1.default.addMinutes(sunset, 72 + offset),
+                    });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.rabbeinuTamZmanios: //tzais72Zmaniot
+                    if (shaaZmanis)
+                        zmanTimes.push({
+                            zmanType,
+                            time: Utils_1.default.addMinutes(sunset, shaaZmanis * 1.2 + offset),
+                        });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.rabbeinuTamZmaniosMga: //tzais72ZmaniotMA
+                    if (shaaZmanisMga)
+                        zmanTimes.push({
+                            zmanType,
+                            time: Utils_1.default.addMinutes(sunset, shaaZmanisMga * 1.2 + offset),
+                        });
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.candleLighting: //candleLighting
+                    if (sunset && jdate.hasCandleLighting()) {
+                        zmanTimes.push({
+                            zmanType,
+                            time: Utils_1.default.addMinutes(Zmanim_1.default.getCandleLightingFromSunset(sunset, location), offset),
+                        });
+                    }
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.SofZmanEatingChometz: //Sof Zman Achilas Chometz
+                    if (shaaZmanisMga && jdate.Month === 1 &&
+                        jdate.Day === 14 &&
+                        Utils_1.default.isTimeAfter(sunrise, Utils_1.default.timeFromDate(date))) {
+                        zmanTimes.push({
+                            zmanType,
+                            time: Utils_1.default.addMinutes(sunrise, -90 + offset + shaaZmanisMga * 4),
+                        });
+                    }
+                    break;
+                case ZmanTypes_1.ZmanTypeIds.SofZmanBurnChometz: //Sof Zman Biur Chometz
+                    if (shaaZmanisMga &&
+                        jdate.Month === 1 &&
+                        (jdate.Day === 14 ||
+                            (jdate.DayOfWeek === exports.DaysOfWeek.FRIDAY &&
+                                jdate.Day === 13)) &&
+                        Utils_1.default.isTimeAfter(sunrise, Utils_1.default.timeFromDate(date))) {
+                        zmanTimes.push({
+                            zmanType,
+                            time: Utils_1.default.addMinutes(sunrise, -90 + offset + shaaZmanisMga * 5),
+                        });
+                    }
+                    break;
+            }
+        }
+        return zmanTimes;
+    }
+    /**
+     * Get the WhichDaysFlags for the given secular date
+     * @param {Date} date
+     * @param {jDate} jdate
+     * @param {Location} location
+     */
+    static getWhichDays(date, jdate, location) {
+        if (jdate.isYomTov(location.Israel)) {
+            return exports.WhichDaysFlags.YOMTOV;
+        }
+        switch (date.getDay()) {
+            case exports.DaysOfWeek.SUNDAY:
+                return exports.WhichDaysFlags.SUNDAY;
+            case exports.DaysOfWeek.MONDAY:
+                return exports.WhichDaysFlags.MONDAY;
+            case exports.DaysOfWeek.TUESDAY:
+                return exports.WhichDaysFlags.TUESDAY;
+            case exports.DaysOfWeek.WEDNESDAY:
+                return exports.WhichDaysFlags.WEDNESDAY;
+            case exports.DaysOfWeek.THURSDAY:
+                return exports.WhichDaysFlags.THURSDAY;
+            case exports.DaysOfWeek.FRIDAY:
+                return exports.WhichDaysFlags.FRIDAY;
+            case exports.DaysOfWeek.SHABBOS:
+                return exports.WhichDaysFlags.SHABBOS;
+        }
+        return 0;
+    }
+    /**
+     * Returns the zmanim necessary for showing basic shul notifications: chatzosHayom, chatzosHalayla, alos
+     * @param {jDate} jdate
+     * @param {Date} sdate
+     * @param {Location} location
+     * @returns {{chatzosHayom:Time, chatzosHalayla:Time, alos:Time, shkia:Time }}
+     */
+    static getBasicShulZmanim(jdate, sdate, location) {
+        const zmanim = AppUtils.getZmanTimes([
+            (0, ZmanTypes_1.getZmanType)(ZmanTypes_1.ZmanTypeIds.chatzosDay),
+            (0, ZmanTypes_1.getZmanType)(ZmanTypes_1.ZmanTypeIds.Alos90),
+            (0, ZmanTypes_1.getZmanType)(ZmanTypes_1.ZmanTypeIds.shkiaElevation),
+            (0, ZmanTypes_1.getZmanType)(ZmanTypes_1.ZmanTypeIds.candleLighting),
+        ], sdate, jdate, location);
+        return {
+            chatzosHayom: zmanim[0].time,
+            chatzosHalayla: Utils_1.default.addMinutes(zmanim[0].time, 720),
+            alos: zmanim[1].time,
+            shkia: zmanim[2].time,
+        };
+    }
+    /**
+    * Returns all the zmanim for the given day
+    * @param {jDate} jdate
+    * @param {Date} sdate
+    * @param {Location} location
+    * @returns {{zmanType:ZmanToShow, time?:Time }[]}
+    */
+    static getAllZmanim(jdate, sdate, location) {
+        return AppUtils.getZmanTimes(ZmanTypes_1.ZmanTypes, sdate, jdate, location);
+    }
+    /**
+     * Compares two zmanim for showing to see if they are the same
+     * @param {{id:number,offset:?Number, whichDaysFlags:?Number, desc: String, eng: String, heb: String }} zman1
+     * @param {{id:number,offset:?Number, whichDaysFlags:?Number, desc: String, eng: String, heb: String }} zman2
+     */
+    static IsSameZmanToShow(zman1, zman2) {
+        return (zman1.id === zman2.id &&
+            zman1.desc === zman2.desc &&
+            zman1.eng === zman2.eng &&
+            zman1.heb === zman2.heb &&
+            (zman1.offset || 0) === (zman2.offset || 0) &&
+            (zman1.whichDaysFlags || 0) === (zman2.whichDaysFlags || 0));
+    }
+    /**
+     * Returns all available ZmanTypes - including baseTypes and custom added types
+     * @param {Settings} settings
+     */
+    static AllZmanTypes(settings) {
+        return [...ZmanTypes_1.ZmanTypes] /*.concat(settings.customZmanim)*/;
+    }
+}
+AppUtils.zmanTimesCache = [];
+exports.default = AppUtils;

package/build/GeneralUtils.d.ts

@@ -0,0 +1,43 @@
+/** Returns true if "thing" is either a string primitive or String object.*/
+export declare function isString(thing: unknown): boolean;
+/** Returns true if "thing" is either a number primitive or a Number object.*/
+export declare function isNumber(thing: unknown): boolean;
+/** Returns true if "thing" is a Date object containing a valid date.*/
+export declare function isValidDate(thing: unknown): boolean;
+/** Returns whether or not the given, array, string, or argument list contains the given item or substring.
+ *
+ * This function is awfully similar to Array.includes, but has the added plus of accepting any number or type of arguments.*/
+export declare function has(o: unknown, ...arr: unknown[]): boolean;
+/** Returns the first value unless it is undefined, null or NaN.
+ *
+ * This is very useful for boolean, string and integer parameters
+ * where we want to keep false, "" and 0 if they were supplied.
+ *
+ * Similar purpose to default parameters with the difference being that this function will return
+ * the second value if the first is NaN or null, while default params will give give you the NaN or the null.
+ */
+export declare function setDefault(paramValue: unknown, defValue: unknown): unknown;
+/**
+ * Returns an array containing a range of integers.
+ * @param {Number} [start] The number to start at. The start number is included in the results.
+ * If only one argument is supplied, start will be set to 1.
+ * @param {Number} end The top end of the range.
+ * Unlike Pythons range function, The end number is included in the results.
+ * @returns {[Number]}
+ */
+export declare function range(start: number, end?: number): number[];
+/**
+ * Log message to console
+ * @param {string} txt
+ */
+export declare function log(txt: string, ...optionalItems: any[]): void;
+/**
+ * Warn message to console
+ * @param {string} txt
+ */
+export declare function warn(txt: string, ...optionalItems: any[]): void;
+/**
+ * Error message to console
+ * @param {*} txt
+ */
+export declare function error(txt: string, ...optionalItems: any[]): void;

package/build/GeneralUtils.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.error = exports.warn = exports.log = exports.range = exports.setDefault = exports.has = exports.isValidDate = exports.isNumber = exports.isString = void 0;
+const __DEV__ = process.env.NODE_ENV === 'development';
+/** Returns true if "thing" is either a string primitive or String object.*/
+function isString(thing) {
+    return typeof thing === 'string' || thing instanceof String;
+}
+exports.isString = isString;
+/** Returns true if "thing" is either a number primitive or a Number object.*/
+function isNumber(thing) {
+    return typeof thing === 'number' || thing instanceof Number;
+}
+exports.isNumber = isNumber;
+/** Returns true if "thing" is a Date object containing a valid date.*/
+function isValidDate(thing) {
+    return thing instanceof Date && !isNaN(thing.valueOf());
+}
+exports.isValidDate = isValidDate;
+/** Returns whether or not the given, array, string, or argument list contains the given item or substring.
+ *
+ * This function is awfully similar to Array.includes, but has the added plus of accepting any number or type of arguments.*/
+function has(o, ...arr) {
+    if (arr.length === 1 && (Array.isArray(arr[0]) || isString(arr[0]))) {
+        return arr[0].includes(o);
+    }
+    else {
+        return arr.includes(o);
+    }
+}
+exports.has = has;
+/** Returns the first value unless it is undefined, null or NaN.
+ *
+ * This is very useful for boolean, string and integer parameters
+ * where we want to keep false, "" and 0 if they were supplied.
+ *
+ * Similar purpose to default parameters with the difference being that this function will return
+ * the second value if the first is NaN or null, while default params will give give you the NaN or the null.
+ */
+function setDefault(paramValue, defValue) {
+    if (typeof paramValue === 'undefined' ||
+        paramValue === null ||
+        isNaN(paramValue)) {
+        return defValue;
+    }
+    else {
+        return paramValue;
+    }
+}
+exports.setDefault = setDefault;
+/**
+ * Returns an array containing a range of integers.
+ * @param {Number} [start] The number to start at. The start number is included in the results.
+ * If only one argument is supplied, start will be set to 1.
+ * @param {Number} end The top end of the range.
+ * Unlike Pythons range function, The end number is included in the results.
+ * @returns {[Number]}
+ */
+function range(start, end) {
+    const startNumber = typeof (end) === 'undefined' ? 1 : start, endNumber = typeof (end) === 'undefined' ? start : end;
+    return Array.from({ length: endNumber - startNumber + 1 }, (v, i) => startNumber + i);
+}
+exports.range = range;
+/**
+ * Log message to console
+ * @param {string} txt
+ */
+function log(txt, ...optionalItems) {
+    if (__DEV__) {
+        console.log(txt, ...optionalItems);
+    }
+}
+exports.log = log;
+/**
+ * Warn message to console
+ * @param {string} txt
+ */
+function warn(txt, ...optionalItems) {
+    if (__DEV__) {
+        console.warn(txt, ...optionalItems);
+    }
+}
+exports.warn = warn;
+/**
+ * Error message to console
+ * @param {*} txt
+ */
+function error(txt, ...optionalItems) {
+    if (__DEV__) {
+        console.error(txt, ...optionalItems);
+    }
+}
+exports.error = error;

package/build/JCal/Dafyomi.d.ts

@@ -0,0 +1,27 @@
+import jDate from './jDate.js';
+/** *********************************************************************************************************
+ * 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: string;
+        heb: string;
+        daf: number;
+    }[];
+    static getDaf(jdate: jDate): {
+        masechet: {
+            eng: string;
+            heb: string;
+            daf: number;
+        };
+        daf: number;
+    } | null;
+    static toString(jd: jDate): string | undefined;
+    static toStringHeb(jd: jDate): string | undefined;
+}