@hebcal/core 5.0.3 → 5.0.5

package/dist/index.mjs

@@ -1,4 +1,4 @@
-/*! @hebcal/core v5.0.3 */
+/*! @hebcal/core v5.0.5 */
 /** @private */
 const lengths = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
 /** @private */
@@ -28,26 +28,6 @@ const ABS_2SEP1752 = 639785;
  */
 var greg;
 (function (greg) {
-    /**
-     * Long names of the Gregorian months (1='January', 12='December')
-     * @readonly
-     * @type {string[]}
-     */
-    greg.monthNames = [
-        '',
-        'January',
-        'February',
-        'March',
-        'April',
-        'May',
-        'June',
-        'July',
-        'August',
-        'September',
-        'October',
-        'November',
-        'December',
-    ];
     /**
      * Returns true if the Gregorian year is a leap year
      * @param {number} year Gregorian year
@@ -4454,6 +4434,300 @@ function getTodayIsHe(omer) {
   return str.normalize();
 }
 
+class QuickLRU extends Map {
+	#size = 0;
+	#cache = new Map();
+	#oldCache = new Map();
+	#maxSize;
+	#maxAge;
+	#onEviction;
+
+	constructor(options = {}) {
+		super();
+
+		if (!(options.maxSize && options.maxSize > 0)) {
+			throw new TypeError('`maxSize` must be a number greater than 0');
+		}
+
+		if (typeof options.maxAge === 'number' && options.maxAge === 0) {
+			throw new TypeError('`maxAge` must be a number greater than 0');
+		}
+
+		this.#maxSize = options.maxSize;
+		this.#maxAge = options.maxAge || Number.POSITIVE_INFINITY;
+		this.#onEviction = options.onEviction;
+	}
+
+	// For tests.
+	get __oldCache() {
+		return this.#oldCache;
+	}
+
+	#emitEvictions(cache) {
+		if (typeof this.#onEviction !== 'function') {
+			return;
+		}
+
+		for (const [key, item] of cache) {
+			this.#onEviction(key, item.value);
+		}
+	}
+
+	#deleteIfExpired(key, item) {
+		if (typeof item.expiry === 'number' && item.expiry <= Date.now()) {
+			if (typeof this.#onEviction === 'function') {
+				this.#onEviction(key, item.value);
+			}
+
+			return this.delete(key);
+		}
+
+		return false;
+	}
+
+	#getOrDeleteIfExpired(key, item) {
+		const deleted = this.#deleteIfExpired(key, item);
+		if (deleted === false) {
+			return item.value;
+		}
+	}
+
+	#getItemValue(key, item) {
+		return item.expiry ? this.#getOrDeleteIfExpired(key, item) : item.value;
+	}
+
+	#peek(key, cache) {
+		const item = cache.get(key);
+
+		return this.#getItemValue(key, item);
+	}
+
+	#set(key, value) {
+		this.#cache.set(key, value);
+		this.#size++;
+
+		if (this.#size >= this.#maxSize) {
+			this.#size = 0;
+			this.#emitEvictions(this.#oldCache);
+			this.#oldCache = this.#cache;
+			this.#cache = new Map();
+		}
+	}
+
+	#moveToRecent(key, item) {
+		this.#oldCache.delete(key);
+		this.#set(key, item);
+	}
+
+	* #entriesAscending() {
+		for (const item of this.#oldCache) {
+			const [key, value] = item;
+			if (!this.#cache.has(key)) {
+				const deleted = this.#deleteIfExpired(key, value);
+				if (deleted === false) {
+					yield item;
+				}
+			}
+		}
+
+		for (const item of this.#cache) {
+			const [key, value] = item;
+			const deleted = this.#deleteIfExpired(key, value);
+			if (deleted === false) {
+				yield item;
+			}
+		}
+	}
+
+	get(key) {
+		if (this.#cache.has(key)) {
+			const item = this.#cache.get(key);
+			return this.#getItemValue(key, item);
+		}
+
+		if (this.#oldCache.has(key)) {
+			const item = this.#oldCache.get(key);
+			if (this.#deleteIfExpired(key, item) === false) {
+				this.#moveToRecent(key, item);
+				return item.value;
+			}
+		}
+	}
+
+	set(key, value, {maxAge = this.#maxAge} = {}) {
+		const expiry = typeof maxAge === 'number' && maxAge !== Number.POSITIVE_INFINITY
+			? (Date.now() + maxAge)
+			: undefined;
+
+		if (this.#cache.has(key)) {
+			this.#cache.set(key, {
+				value,
+				expiry,
+			});
+		} else {
+			this.#set(key, {value, expiry});
+		}
+
+		return this;
+	}
+
+	has(key) {
+		if (this.#cache.has(key)) {
+			return !this.#deleteIfExpired(key, this.#cache.get(key));
+		}
+
+		if (this.#oldCache.has(key)) {
+			return !this.#deleteIfExpired(key, this.#oldCache.get(key));
+		}
+
+		return false;
+	}
+
+	peek(key) {
+		if (this.#cache.has(key)) {
+			return this.#peek(key, this.#cache);
+		}
+
+		if (this.#oldCache.has(key)) {
+			return this.#peek(key, this.#oldCache);
+		}
+	}
+
+	delete(key) {
+		const deleted = this.#cache.delete(key);
+		if (deleted) {
+			this.#size--;
+		}
+
+		return this.#oldCache.delete(key) || deleted;
+	}
+
+	clear() {
+		this.#cache.clear();
+		this.#oldCache.clear();
+		this.#size = 0;
+	}
+
+	resize(newSize) {
+		if (!(newSize && newSize > 0)) {
+			throw new TypeError('`maxSize` must be a number greater than 0');
+		}
+
+		const items = [...this.#entriesAscending()];
+		const removeCount = items.length - newSize;
+		if (removeCount < 0) {
+			this.#cache = new Map(items);
+			this.#oldCache = new Map();
+			this.#size = items.length;
+		} else {
+			if (removeCount > 0) {
+				this.#emitEvictions(items.slice(0, removeCount));
+			}
+
+			this.#oldCache = new Map(items.slice(removeCount));
+			this.#cache = new Map();
+			this.#size = 0;
+		}
+
+		this.#maxSize = newSize;
+	}
+
+	* keys() {
+		for (const [key] of this) {
+			yield key;
+		}
+	}
+
+	* values() {
+		for (const [, value] of this) {
+			yield value;
+		}
+	}
+
+	* [Symbol.iterator]() {
+		for (const item of this.#cache) {
+			const [key, value] = item;
+			const deleted = this.#deleteIfExpired(key, value);
+			if (deleted === false) {
+				yield [key, value.value];
+			}
+		}
+
+		for (const item of this.#oldCache) {
+			const [key, value] = item;
+			if (!this.#cache.has(key)) {
+				const deleted = this.#deleteIfExpired(key, value);
+				if (deleted === false) {
+					yield [key, value.value];
+				}
+			}
+		}
+	}
+
+	* entriesDescending() {
+		let items = [...this.#cache];
+		for (let i = items.length - 1; i >= 0; --i) {
+			const item = items[i];
+			const [key, value] = item;
+			const deleted = this.#deleteIfExpired(key, value);
+			if (deleted === false) {
+				yield [key, value.value];
+			}
+		}
+
+		items = [...this.#oldCache];
+		for (let i = items.length - 1; i >= 0; --i) {
+			const item = items[i];
+			const [key, value] = item;
+			if (!this.#cache.has(key)) {
+				const deleted = this.#deleteIfExpired(key, value);
+				if (deleted === false) {
+					yield [key, value.value];
+				}
+			}
+		}
+	}
+
+	* entriesAscending() {
+		for (const [key, value] of this.#entriesAscending()) {
+			yield [key, value.value];
+		}
+	}
+
+	get size() {
+		if (!this.#size) {
+			return this.#oldCache.size;
+		}
+
+		let oldCacheSize = 0;
+		for (const key of this.#oldCache.keys()) {
+			if (!this.#cache.has(key)) {
+				oldCacheSize++;
+			}
+		}
+
+		return Math.min(this.#size + oldCacheSize, this.#maxSize);
+	}
+
+	get maxSize() {
+		return this.#maxSize;
+	}
+
+	entries() {
+		return this.entriesAscending();
+	}
+
+	forEach(callbackFunction, thisArgument = this) {
+		for (const [key, value] of this.entriesAscending()) {
+			callbackFunction.call(thisArgument, value, key, this);
+		}
+	}
+
+	get [Symbol.toStringTag]() {
+		return JSON.stringify([...this.entriesAscending()]);
+	}
+}
+
 /* eslint-disable new-cap */
 /*
     Hebcal - A Jewish Calendar Generator
@@ -4618,7 +4892,6 @@ class Sedra {
   }
 
   /**
-   * @private
    * @return {Object[]}
    */
   getSedraArray() {
@@ -4651,7 +4924,7 @@ class Sedra {
     const weekNum = (saturday - this.firstSaturday) / 7;
     const index = this.theSedraArray[weekNum];
     if (typeof index === 'undefined') {
-      const sedra = new Sedra(this.year + 1, this.il);
+      const sedra = getSedra_(this.year + 1, this.il);
       return sedra.lookup(saturday); // must be next year
     }
     if (typeof index === 'string') {
@@ -4841,6 +5114,25 @@ types['1311'] = types['1221'];
 /* Hebrew year that starts on Saturday, is `complete' (Heshvan and
  * Kislev each have 30 days), and has Passover start on Thursday. */
 types['1721'] = types['170'];
+const sedraCache = new QuickLRU({
+  maxSize: 400
+});
+
+/**
+ * @private
+ * @param {number} hyear
+ * @param {boolean} il
+ * @return {Sedra}
+ */
+function getSedra_(hyear, il) {
+  const cacheKey = `${hyear}-${il ? 1 : 0}`;
+  let sedra = sedraCache.get(cacheKey);
+  if (!sedra) {
+    sedra = new Sedra(hyear, il);
+    sedraCache.set(cacheKey, sedra);
+  }
+  return sedra;
+}
 
 /**
  * Represents one of 54 weekly Torah portions, always on a Saturday
@@ -5608,28 +5900,13 @@ const KISLEV = months.KISLEV;
 const TEVET = months.TEVET;
 const ADAR_I = months.ADAR_I;
 const ADAR_II = months.ADAR_II;
-const sedraCache = new Map();
-
-/**
- * @private
- * @param {number} hyear
- * @param {boolean} il
- * @return {Sedra}
- */
-function getSedra_(hyear, il) {
-  const cacheKey = `${hyear}-${il ? 1 : 0}`;
-  let sedra = sedraCache.get(cacheKey);
-  if (!sedra) {
-    sedra = new Sedra(hyear, il);
-    sedraCache.set(cacheKey, sedra);
-  }
-  return sedra;
-}
 const emojiIsraelFlag = {
   emoji: '🇮🇱'
 };
 const chanukahEmoji = '🕎';
-const yearCache = new Map();
+const yearCache = new QuickLRU({
+  maxSize: 400
+});
 const KEYCAP_DIGITS = ['0️⃣', '1️⃣', '2️⃣', '3️⃣', '4️⃣', '5️⃣', '6️⃣', '7️⃣', '8️⃣', '9️⃣'];
 
 /**
@@ -5885,7 +6162,7 @@ class DailyLearning {
 }
 
 // DO NOT EDIT THIS AUTO-GENERATED FILE!
-const version = '5.0.3';
+const version = '5.0.5';
 
 const NONE$1 = 0;
 const HALF = 1;
@@ -6330,7 +6607,6 @@ function range(start, end) {
   }
   return arr;
 }
-const cache = new Map();
 const NONE = {
   shacharit: false,
   mincha: false,
@@ -6356,12 +6632,7 @@ function tachanun_(hdate, il) {
  */
 function tachanun0(hdate, il, checkNext) {
   const year = hdate.getFullYear();
-  const key = `${year}-${il ? 1 : 0}`;
-  const cached = cache.get(key);
-  const dates = cached || tachanunYear(year, il);
-  if (!cached) {
-    cache.set(key, dates);
-  }
+  const dates = tachanunYear(year, il);
   const abs = hdate.abs();
   if (dates.none.indexOf(abs) > -1) {
     return NONE;
@@ -6911,8 +7182,6 @@ function observedInIsrael(ev) {
 function observedInDiaspora(ev) {
   return ev.observedInDiaspora();
 }
-const yearArrayCache = new Map();
-const holidaysOnDate = new Map();
 
 /**
  * HebrewCalendar is the main interface to the `@hebcal/core` library.
@@ -7237,15 +7506,10 @@ class HebrewCalendar {
    * @return {Event[]}
    */
   static getHolidaysForYearArray(year, il) {
-    const cacheKey = `${year}-${il ? 1 : 0}`;
-    let events = yearArrayCache.get(cacheKey);
-    if (events) {
-      return events;
-    }
     const yearMap = getHolidaysForYear_(year);
     const startAbs = HDate.hebrew2abs(year, TISHREI, 1);
     const endAbs = HDate.hebrew2abs(year + 1, TISHREI, 1) - 1;
-    events = [];
+    let events = [];
     const myFilter = il ? observedInIsrael : observedInDiaspora;
     for (let absDt = startAbs; absDt <= endAbs; absDt++) {
       const hd = new HDate(absDt);
@@ -7255,7 +7519,6 @@ class HebrewCalendar {
         events = events.concat(filtered);
       }
     }
-    yearArrayCache.set(cacheKey, events);
     return events;
   }
 
@@ -7268,20 +7531,14 @@ class HebrewCalendar {
   static getHolidaysOnDate(date, il) {
     const hd = HDate.isHDate(date) ? date : new HDate(date);
     const hdStr = hd.toString();
-    const cacheKey = hdStr + '/' + (typeof il === 'undefined' ? 2 : il ? 1 : 0);
-    if (holidaysOnDate.has(cacheKey)) {
-      return holidaysOnDate.get(cacheKey);
-    }
     const yearMap = getHolidaysForYear_(hd.getFullYear());
     const events = yearMap.get(hdStr);
     // if il isn't a boolean return both diaspora + IL for day
     if (typeof il === 'undefined' || typeof events === 'undefined') {
-      holidaysOnDate.set(cacheKey, events);
       return events;
     }
     const myFilter = il ? observedInIsrael : observedInDiaspora;
     const filtered = events.filter(myFilter);
-    holidaysOnDate.set(cacheKey, filtered);
     return filtered;
   }
 

package/hebcal.d.ts

@@ -820,12 +820,6 @@ declare module '@hebcal/core' {
      * Gregorian date helper functions.
      */
     export namespace greg {
-        /**
-         * Long names of the Gregorian months (1='January', 12='December')
-         * @readonly
-         * @type {string[]}
-         */
-        const monthNames: string[];
         /**
          * Returns true if the Gregorian year is a leap year
          * @param {number} year Gregorian year
@@ -983,6 +977,7 @@ declare module '@hebcal/core' {
          */
         find(parsha: number | string | string[]): HDate;
         getYear(): number;
+        getSedraArray(): any[];
         /**
          * R.D. date of the first Saturday on or after Rosh Hashana
          */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hebcal/core",
-  "version": "5.0.3",
+  "version": "5.0.5",
   "author": "Michael J. Radwin (https://github.com/mjradwin)",
   "contributors": [
     "Eyal Schachter (https://github.com/Scimonster)",
@@ -34,7 +34,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/hebcal/hebcal-es6.git"
+    "url": "git+https://github.com/hebcal/hebcal-es6.git"
   },
   "bugs": {
     "url": "https://github.com/hebcal/hebcal-es6/issues"
@@ -73,7 +73,7 @@
     "@babel/core": "^7.23.6",
     "@babel/preset-env": "^7.23.6",
     "@babel/register": "^7.22.15",
-    "@hebcal/hdate": "^0.9.0",
+    "@hebcal/hdate": "^0.9.1",
     "@hebcal/noaa": "^0.8.11",
     "@rollup/plugin-babel": "^6.0.4",
     "@rollup/plugin-commonjs": "^25.0.7",
@@ -87,6 +87,7 @@
     "jsdoc": "^4.0.2",
     "jsdoc-to-markdown": "^8.0.0",
     "nyc": "^15.1.0",
+    "quick-lru": "^7.0.0",
     "rollup": "^4.9.1",
     "ttag-cli": "^1.10.10"
   }