@hebcal/core 6.0.6 → 6.0.8

package/dist/size-demo/getHoliday.d.ts

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

package/dist/size-demo/getHoliday.js

@@ -0,0 +1,3 @@
+import { HDate } from '@hebcal/hdate';
+import { getHolidaysOnDate } from '../dist/esm/holidays';
+console.log(getHolidaysOnDate(new HDate(1, 1, 5757)));

package/dist/size-demo/parshiyot.d.ts

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

package/dist/size-demo/parshiyot.js

@@ -0,0 +1,11 @@
+import { calendar } from '../dist/esm/calendar';
+const events = calendar({
+    year: new Date().getFullYear() - 1,
+    numYears: 2,
+    sedrot: true,
+    noHolidays: true,
+});
+console.log(events.map(event => ({
+    datetime: event.date.greg(),
+    label: event.render('he-x-NoNikud'),
+})));

package/dist/size-demo/rollup.config.d.ts

@@ -0,0 +1,3 @@
+import { RollupOptions } from 'rollup';
+declare const _default: RollupOptions[];
+export default _default;

package/dist/size-demo/rollup.config.js

@@ -0,0 +1,47 @@
+import prettyBytes from 'pretty-bytes';
+import { defineConfig } from 'rollup';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import bundleSize from 'rollup-plugin-bundle-size';
+import terser from '@rollup/plugin-terser';
+import typescript from '@rollup/plugin-typescript';
+import { appendFileSync, readdirSync, writeFileSync } from 'fs';
+import { basename } from 'path';
+import { visualizer } from 'rollup-plugin-visualizer';
+const sizeFile = './size-demo/sizes.md';
+writeFileSync(sizeFile, '# Bundle sizes\n\n');
+export default defineConfig(readdirSync('./size-demo')
+    .filter(f => f.endsWith('.ts'))
+    .filter(f => !f.endsWith('.d.ts') && !f.endsWith('.config.ts'))
+    .map((file) => {
+    const name = basename(file, '.ts');
+    return {
+        input: `size-demo/${name}.ts`,
+        output: [
+            {
+                file: `size-demo/dist/${name}.js`,
+                format: 'es',
+                inlineDynamicImports: true,
+            },
+            {
+                file: `size-demo/dist/${name}.min.js`,
+                format: 'es',
+                inlineDynamicImports: true,
+                plugins: [terser()],
+            },
+        ],
+        plugins: [
+            typescript({ tsconfig: './size-demo/tsconfig.json' }),
+            nodeResolve(),
+            bundleSize(),
+            {
+                name: 'record-size-to-file',
+                generateBundle(options, bundle) {
+                    const asset = basename(options.file);
+                    const result = bundle[asset];
+                    appendFileSync(sizeFile, `- \`${asset}\`: ${prettyBytes(result.code.length)}\n`);
+                },
+            },
+            visualizer({ filename: `size-demo/dist/${name}.stats.html` }),
+        ],
+    };
+}));

package/dist/size-demo/sedra.d.ts

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

package/dist/size-demo/sedra.js

@@ -0,0 +1,3 @@
+import { getSedra } from '../dist/esm/sedra';
+const sedra = getSedra(5757, false);
+console.log(sedra.lookup(729122).parsha);

package/dist/size-demo/tachanun.d.ts

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

package/dist/size-demo/tachanun.js

@@ -0,0 +1,3 @@
+import { tachanun } from '../dist/esm/tachanun';
+import { HDate } from '@hebcal/hdate';
+console.log(tachanun(new HDate(1, 1, 5757), true));

package/dist/src/CalOptions.d.ts

@@ -0,0 +1,168 @@
+import { HDate } from '@hebcal/hdate';
+import type { Location } from './location';
+export type DailyLearningValue = boolean | number | string;
+/**
+ * Options to configure which events are returned
+ */
+export type CalOptions = {
+    /**
+     * latitude/longitude/tzid used for candle-lighting
+     */
+    location?: Location;
+    /**
+     * Gregorian or Hebrew year
+     */
+    year?: number;
+    /**
+     * to interpret year as Hebrew year
+     */
+    isHebrewYear?: boolean;
+    /**
+     * Gregorian or Hebrew month (to filter results to a single month)
+     */
+    month?: number | string;
+    /**
+     * generate calendar for multiple years (default 1)
+     */
+    numYears?: number;
+    /**
+     * use specific start date (requires end date)
+     */
+    start?: number | HDate | Date;
+    /**
+     * use specific end date (requires start date)
+     */
+    end?: number | HDate | Date;
+    /**
+     * calculate candle-lighting and havdalah times
+     */
+    candlelighting?: boolean;
+    /**
+     * minutes before sundown to light candles (default 18)
+     */
+    candleLightingMins?: number;
+    /**
+     * minutes after sundown for Havdalah (typical values are 42, 50, or 72).
+     * If `undefined` (the default), calculate Havdalah according to Tzeit Hakochavim -
+     * Nightfall (the point when 3 small stars are observable in the night time sky with
+     * the naked eye). If `0`, Havdalah times are suppressed.
+     */
+    havdalahMins?: number;
+    /**
+     * degrees for solar depression for Havdalah.
+     * Default is 8.5 degrees for 3 small stars. use 7.083 degrees for 3 medium-sized stars
+     * (observed by Dr. Baruch (Berthold) Cohn in his luach published in France in 1899).
+     * If `0`, Havdalah times are suppressed.
+     */
+    havdalahDeg?: number;
+    /**
+     * degrees for solar depression for end of fast days.
+     * Default is 7.083 degrees for 3 medium-sized stars. Other commonly-used values include
+     * 6.45 degrees, as calculated by Rabbi Yechiel Michel Tucazinsky.
+     */
+    fastEndDeg?: number;
+    /**
+     * use elevation for calculations (default `false`).
+     * If `true`, use elevation to affect the calculation of all sunrise/sunset based zmanim.
+     * Note: there are some zmanim such as degree-based zmanim that are driven by the amount
+     * of light in the sky and are not impacted by elevation.
+     * These zmanim intentionally do not support elevation adjustment.
+     */
+    useElevation?: boolean;
+    /**
+     * calculate parashah hashavua on Saturdays
+     */
+    sedrot?: boolean;
+    /**
+     * Israeli holiday and sedra schedule
+     */
+    il?: boolean;
+    /**
+     * suppress minor fasts
+     */
+    noMinorFast?: boolean;
+    /**
+     * suppress modern holidays
+     */
+    noModern?: boolean;
+    /**
+     * suppress Rosh Chodesh
+     */
+    noRoshChodesh?: boolean;
+    /**
+     * add Shabbat Mevarchim
+     */
+    shabbatMevarchim?: boolean;
+    /**
+     * suppress Special Shabbat
+     */
+    noSpecialShabbat?: boolean;
+    /**
+     * suppress regular holidays
+     */
+    noHolidays?: boolean;
+    /**
+     * include Days of the Omer
+     */
+    omer?: boolean;
+    /**
+     * include event announcing the molad
+     */
+    molad?: boolean;
+    /**
+     * use Ashkenazi transliterations for event titles (default Sephardi transliterations)
+     * @deprecated use `event.render('ashkenazi')` instead
+     */
+    ashkenazi?: boolean;
+    /**
+     * translate event titles according to a locale
+     * Default value is `en`, also built-in are `he` and `ashkenazi`.
+     * Additional locales (such as `ru` or `fr`) are provided by the
+     * {@link https://github.com/hebcal/hebcal-locales @hebcal/locales} package
+     */
+    locale?: string;
+    /**
+     * print the Hebrew date for the entire date range
+     */
+    addHebrewDates?: boolean;
+    /**
+     * print the Hebrew date for dates with some events
+     */
+    addHebrewDatesForEvents?: boolean;
+    /**
+     * use bitmask from `flags` to filter events
+     */
+    mask?: number;
+    /**
+     * include Yom Kippur Katan (default `false`).
+     * יוֹם כִּפּוּר קָטָן is a minor day of atonement occurring monthly on the day preceeding each Rosh Chodesh.
+     * Yom Kippur Katan is omitted in Elul (on the day before Rosh Hashanah),
+     * Tishrei (Yom Kippur has just passed), Kislev (due to Chanukah)
+     * and Nisan (fasting not permitted during Nisan).
+     * When Rosh Chodesh occurs on Shabbat or Sunday, Yom Kippur Katan is observed on the preceding Thursday.
+     * See {@link https://en.wikipedia.org/wiki/Yom_Kippur_Katan#Practices Wikipedia Yom Kippur Katan practices}
+     */
+    yomKippurKatan?: boolean;
+    /**
+     * Whether to use 12-hour time (as opposed to 24-hour time).
+     * Possible values are `true` and `false`; the default is locale dependent.
+     */
+    hour12?: boolean;
+    /**
+     * map of options to enable daily study calendars
+     * such as `dafYomi`, `mishnaYomi`, `nachYomi` with value `true`. For `yerushalmi`
+     * the value should be a `number` for edition (`1` for Vilna, `2` for Schottenstein).
+     */
+    dailyLearning?: Record<string, DailyLearningValue>;
+    /**
+     * Yizkor (Hebrew: יִזְכּוֹר) is an Ashkenazi Jewish memorial prayer service
+     * for the dead. Yizkor is recited in synagogue as part of the service
+     * during four holidays each year:
+     * 1. Yom Kippur
+     * 2. Shmini Atzeret
+     * 3. The final day of Passover (8th day Pesach in Diaspora, 7th day
+     *    Pesach in Israel)
+     * 4. Shavuot (2nd day Shavuot in Diaspora)
+     */
+    yizkor?: boolean;
+};

package/dist/src/CalOptions.js

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

package/dist/src/DailyLearning.d.ts

@@ -0,0 +1,32 @@
+import { HDate } from '@hebcal/hdate';
+import { Event } from './event';
+/**
+ * Plug-ins for daily learning calendars such as Daf Yomi, Mishna Yomi, Nach Yomi, etc.
+ *
+ * Learning schedules are provided by the `@hebcal/learning` package.
+ */
+export declare class DailyLearning {
+    /**
+     * Register a new learning calendar.
+     * @param name case insensitive
+     * @param calendar a function that returns an `Event` or `null`
+     * @param startDate the first date for which this calendar is valid
+     */
+    static addCalendar(name: string, calendar: Function, startDate?: HDate): void;
+    /**
+     * Returns an event from daily calendar for a given date. Returns `null` if there
+     * is no learning from this calendar on this date.
+     * @param name case insensitive
+     * @param hd Hebrew Date
+     * @param il true for Israel, false for Diaspora
+     */
+    static lookup(name: string, hd: HDate, il: boolean): Event | null;
+    static getStartDate(name: string): HDate | undefined;
+    /**
+     * Tests to see if learning calendar has been registered
+     * @param name case insensitive
+     */
+    static has(name: string): boolean;
+    /** Returns the names of all calendars registered */
+    static getCalendars(): string[];
+}

package/dist/src/DailyLearning.js

@@ -0,0 +1,55 @@
+const cals = new Map();
+/**
+ * Plug-ins for daily learning calendars such as Daf Yomi, Mishna Yomi, Nach Yomi, etc.
+ *
+ * Learning schedules are provided by the `@hebcal/learning` package.
+ */
+export class DailyLearning {
+    /**
+     * Register a new learning calendar.
+     * @param name case insensitive
+     * @param calendar a function that returns an `Event` or `null`
+     * @param startDate the first date for which this calendar is valid
+     */
+    static addCalendar(name, calendar, startDate) {
+        if (typeof calendar !== 'function') {
+            throw new TypeError(`Invalid calendar function: ${calendar}`);
+        }
+        cals.set(name.toLowerCase(), {
+            fn: calendar,
+            startDate: startDate,
+        });
+    }
+    /**
+     * Returns an event from daily calendar for a given date. Returns `null` if there
+     * is no learning from this calendar on this date.
+     * @param name case insensitive
+     * @param hd Hebrew Date
+     * @param il true for Israel, false for Diaspora
+     */
+    static lookup(name, hd, il) {
+        const cal = cals.get(name.toLowerCase());
+        if (typeof cal === 'object') {
+            return cal.fn(hd, il);
+        }
+        return null;
+    }
+    static getStartDate(name) {
+        const cal = cals.get(name.toLowerCase());
+        if (typeof cal === 'object') {
+            return cal.startDate;
+        }
+        return undefined;
+    }
+    /**
+     * Tests to see if learning calendar has been registered
+     * @param name case insensitive
+     */
+    static has(name) {
+        return cals.has(name.toLowerCase());
+    }
+    /** Returns the names of all calendars registered */
+    static getCalendars() {
+        return Array.from(cals.keys());
+    }
+}

package/dist/src/HebrewDateEvent.d.ts

@@ -0,0 +1,37 @@
+import { HDate } from '@hebcal/hdate';
+import { Event } from './event';
+import './locale';
+/** Daily Hebrew date ("11th of Sivan, 5780") */
+export declare class HebrewDateEvent extends Event {
+    /**
+     * @param date
+     */
+    constructor(date: HDate);
+    /**
+     * @param [locale] Optional locale name (defaults to empty locale)
+     * @example
+     * import {HDate, HebrewDateEvent, months} from '@hebcal/core';
+     *
+     * const hd = new HDate(15, months.CHESHVAN, 5769);
+     * const ev = new HebrewDateEvent(hd);
+     * console.log(ev.render('en')); // '15th of Cheshvan, 5769'
+     * console.log(ev.render('he')); // 'ט״ו חֶשְׁוָן תשס״ט'
+     */
+    render(locale?: string): string;
+    /**
+     * @private
+     * @param locale
+     */
+    private renderBriefHebrew;
+    /**
+     * @param [locale] Optional locale name (defaults to empty locale)
+     * @example
+     * import {HDate, HebrewDateEvent, months} from '@hebcal/core';
+     *
+     * const hd = new HDate(15, months.CHESHVAN, 5769);
+     * const ev = new HebrewDateEvent(hd);
+     * console.log(ev.renderBrief()); // '15th of Cheshvan'
+     * console.log(ev.renderBrief('he')); // 'ט״ו חֶשְׁוָן'
+     */
+    renderBrief(locale?: string): string;
+}

package/dist/src/HebrewDateEvent.js

@@ -0,0 +1,72 @@
+import { gematriya, months, Locale } from '@hebcal/hdate';
+import { Event, flags } from './event';
+import './locale'; // Adds Hebrew and Ashkenazic translations
+/** Daily Hebrew date ("11th of Sivan, 5780") */
+export class HebrewDateEvent extends Event {
+    /**
+     * @param date
+     */
+    constructor(date) {
+        super(date, date.toString(), flags.HEBREW_DATE);
+    }
+    /**
+     * @param [locale] Optional locale name (defaults to empty locale)
+     * @example
+     * import {HDate, HebrewDateEvent, months} from '@hebcal/core';
+     *
+     * const hd = new HDate(15, months.CHESHVAN, 5769);
+     * const ev = new HebrewDateEvent(hd);
+     * console.log(ev.render('en')); // '15th of Cheshvan, 5769'
+     * console.log(ev.render('he')); // 'ט״ו חֶשְׁוָן תשס״ט'
+     */
+    render(locale) {
+        const locale1 = locale === null || locale === void 0 ? void 0 : locale.toLowerCase();
+        const locale0 = locale1 !== null && locale1 !== void 0 ? locale1 : 'en';
+        const hd = this.getDate();
+        switch (locale0) {
+            case 'h':
+            case 'he':
+                return hd.renderGematriya(false);
+            case 'he-x-nonikud':
+                return hd.renderGematriya(true);
+            default:
+                return hd.render(locale0, true);
+        }
+    }
+    /**
+     * @private
+     * @param locale
+     */
+    renderBriefHebrew(locale) {
+        const hd = this.getDate();
+        const dd = hd.getDate();
+        const mm = Locale.gettext(hd.getMonthName(), locale);
+        return gematriya(dd) + ' ' + mm;
+    }
+    /**
+     * @param [locale] Optional locale name (defaults to empty locale)
+     * @example
+     * import {HDate, HebrewDateEvent, months} from '@hebcal/core';
+     *
+     * const hd = new HDate(15, months.CHESHVAN, 5769);
+     * const ev = new HebrewDateEvent(hd);
+     * console.log(ev.renderBrief()); // '15th of Cheshvan'
+     * console.log(ev.renderBrief('he')); // 'ט״ו חֶשְׁוָן'
+     */
+    renderBrief(locale) {
+        const locale1 = locale === null || locale === void 0 ? void 0 : locale.toLowerCase();
+        const locale0 = locale1 !== null && locale1 !== void 0 ? locale1 : 'en';
+        const hd = this.getDate();
+        if (hd.getMonth() === months.TISHREI && hd.getDate() === 1) {
+            return this.render(locale0);
+        }
+        switch (locale0) {
+            case 'h':
+            case 'he':
+            case 'he-x-nonikud':
+                return this.renderBriefHebrew(locale0);
+            default:
+                return hd.render(locale0, false);
+        }
+    }
+}

package/dist/src/HolidayEvent.d.ts

@@ -0,0 +1,83 @@
+import { HDate } from '@hebcal/hdate';
+import { Event } from './event';
+import './locale';
+/** Represents a built-in holiday like Pesach, Purim or Tu BiShvat */
+export declare class HolidayEvent extends Event {
+    /** During Sukkot or Pesach */
+    cholHaMoedDay?: number;
+    /**
+     * `true` if the fast day was postponed a day to avoid Shabbat.
+     * - Tish'a B'Av postponed from the 9th to the 10th
+     * - Tzom Tammuz postponed from the 17th to the 18th
+     */
+    observed?: boolean;
+    basename(): string;
+    url(): string | undefined;
+    urlDateSuffix(): string;
+    getEmoji(): string;
+    getCategories(): string[];
+    /**
+     * Returns (translated) description of this event
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    render(locale?: string): string;
+    /**
+     * Returns a brief (translated) description of this event.
+     * For most events, this is the same as render(). For some events, it procudes
+     * a shorter text (e.g. without a time or added description).
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    renderBrief(locale?: string): string;
+}
+/**
+ * Because Asara B'Tevet often occurs twice in the same Gregorian year,
+ * we subclass HolidayEvent to generate the correct URL.
+ */
+export declare class AsaraBTevetEvent extends HolidayEvent {
+    urlDateSuffix(): string;
+}
+/**
+ * Because Chanukah sometimes starts in December and ends in January,
+ * we subclass HolidayEvent to generate the correct URL.
+ */
+export declare class ChanukahEvent extends HolidayEvent {
+    readonly chanukahDay?: number;
+    /**
+     * @param chanukahDay should be undefined for 1st night of Chanukah
+     */
+    constructor(date: HDate, desc: string, mask: number, chanukahDay?: number);
+    urlDateSuffix(): string;
+}
+/** Represents Rosh Hashana, the Jewish New Year */
+export declare class RoshHashanaEvent extends HolidayEvent {
+    private readonly hyear;
+    /**
+     * @private
+     * @param date Hebrew date event occurs
+     * @param hyear Hebrew year
+     * @param mask optional holiday flags
+     */
+    constructor(date: HDate, hyear: number, mask: number);
+    /**
+     * Returns (translated) description of this event
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    render(locale?: string): string;
+    getEmoji(): string;
+}
+/** Represents Rosh Chodesh, the beginning of a new month */
+export declare class RoshChodeshEvent extends HolidayEvent {
+    /**
+     * Constructs Rosh Chodesh event
+     * @param date Hebrew date event occurs
+     * @param monthName Hebrew month name (not translated)
+     */
+    constructor(date: HDate, monthName: string);
+    /**
+     * Returns (translated) description of this event
+     * @param [locale] Optional locale name (defaults to empty locale)
+     */
+    render(locale?: string): string;
+    basename(): string;
+    getEmoji(): string;
+}