bg-name-days 2.0.0

package/src/normalize.js

@@ -0,0 +1,60 @@
+/** @typedef {import('./types.js').NameDayEntry} NameDayEntry */
+
+/**
+ * Normalize a string for case-insensitive matching.
+ * Trims whitespace and lowercases.
+ * @param {string} str
+ * @returns {string}
+ */
+export function normalize(str) {
+  if (!str || typeof str !== 'string') return '';
+  return str.trim().toLowerCase();
+}
+
+/**
+ * Format a Date or "MM-DD" string to "MM-DD".
+ * @param {string|Date} date
+ * @returns {string|null}
+ */
+export function formatDate(date) {
+  if (!date) return null;
+
+  if (typeof date === 'string') {
+    // Validate "MM-DD" format
+    if (/^\d{2}-\d{2}$/.test(date)) return date;
+    // Try to parse as Date string
+    const parsed = new Date(date);
+    if (Number.isNaN(parsed.getTime())) return null;
+    return pad(parsed.getMonth() + 1) + '-' + pad(parsed.getDate());
+  }
+
+  if (date instanceof Date) {
+    if (Number.isNaN(date.getTime())) return null;
+    return pad(date.getMonth() + 1) + '-' + pad(date.getDate());
+  }
+
+  return null;
+}
+
+/**
+ * Extract year from a Date.
+ * @param {string|Date} date
+ * @returns {number}
+ */
+export function extractYear(date) {
+  if (date instanceof Date) return date.getFullYear();
+  if (typeof date === 'string') {
+    const parsed = new Date(date);
+    if (!Number.isNaN(parsed.getTime())) return parsed.getFullYear();
+  }
+  return new Date().getFullYear();
+}
+
+/**
+ * Pad a number to 2 digits.
+ * @param {number} n
+ * @returns {string}
+ */
+function pad(n) {
+  return String(n).padStart(2, '0');
+}

package/src/search.js

@@ -0,0 +1,78 @@
+/** @typedef {import('./types.js').SearchResult} SearchResult */
+
+import { getIndex } from './data/nameDays.js';
+import { normalize } from './normalize.js';
+
+/**
+ * Search names by prefix. Searches primary names, variants, and Latin transliterations.
+ * Case-insensitive. Returns unique SearchResult objects.
+ *
+ * @param {string} prefix - Prefix to search for (Cyrillic or Latin)
+ * @param {number} [year] - Year for moveable dates (default: current year)
+ * @returns {SearchResult[]}
+ */
+export function searchNames(prefix, year) {
+  if (!prefix || typeof prefix !== 'string') return [];
+
+  const key = normalize(prefix);
+  if (key.length === 0) return [];
+
+  const y = year ?? new Date().getFullYear();
+  const idx = getIndex(y);
+
+  /** @type {Map<string, SearchResult>} */
+  const resultMap = new Map();
+
+  for (const [nameKey, entries] of idx.byName) {
+    if (!nameKey.startsWith(key)) continue;
+
+    for (const entry of entries) {
+      const dateStr = `${String(entry.month).padStart(2, '0')}-${String(entry.day).padStart(2, '0')}`;
+      const resultKey = `${entry.name}|${dateStr}`;
+
+      if (!resultMap.has(resultKey)) {
+        resultMap.set(resultKey, {
+          name: entry.name,
+          date: dateStr,
+          holiday: entry.holiday,
+        });
+      }
+    }
+  }
+
+  return [...resultMap.values()];
+}
+
+/**
+ * Get all names celebrating a specific holiday.
+ * Case-insensitive partial match.
+ *
+ * @param {string} holidayName - Holiday name to search for (Cyrillic or Latin)
+ * @param {number} [year] - Year for moveable dates (default: current year)
+ * @returns {string[]} Array of all celebrating names (primary + variants)
+ */
+export function getNamesByHoliday(holidayName, year) {
+  if (!holidayName || typeof holidayName !== 'string') return [];
+
+  const key = normalize(holidayName);
+  if (key.length === 0) return [];
+
+  const y = year ?? new Date().getFullYear();
+  const idx = getIndex(y);
+
+  const names = [];
+
+  for (const [holidayKey, entries] of idx.byHoliday) {
+    if (!holidayKey.includes(key)) continue;
+
+    for (const entry of entries) {
+      names.push(entry.name);
+      for (const variant of entry.variants) {
+        names.push(variant);
+      }
+    }
+  }
+
+  // Deduplicate while preserving order
+  return [...new Set(names)];
+}

package/src/transliterate.js

@@ -0,0 +1,56 @@
+import { cyrToLat, latToCyr, latKeys } from "./data/transliteration-map.js";
+
+const CYR_REGEX = /[\u0400-\u04FF]/;
+
+/**
+ * Detects if text contains Cyrillic characters.
+ */
+function isCyrillic(text) {
+  return CYR_REGEX.test(text);
+}
+
+/**
+ * Transliterates Cyrillic text to Latin.
+ */
+function cyrillicToLatin(text) {
+  let result = "";
+  for (const char of text) {
+    result += cyrToLat[char] ?? char;
+  }
+  return result;
+}
+
+/**
+ * Transliterates Latin text to Cyrillic.
+ */
+function latinToCyrillic(text) {
+  let result = "";
+  let i = 0;
+  while (i < text.length) {
+    let matched = false;
+    for (const key of latKeys) {
+      if (text.startsWith(key, i)) {
+        result += latToCyr[key];
+        i += key.length;
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      result += text[i];
+      i++;
+    }
+  }
+  return result;
+}
+
+/**
+ * Auto-detect direction and transliterate.
+ * Cyrillic input → Latin output, Latin input → Cyrillic output.
+ * @param {string} text
+ * @returns {string}
+ */
+export function transliterate(text) {
+  if (typeof text !== "string" || text.length === 0) return "";
+  return isCyrillic(text) ? cyrillicToLatin(text) : latinToCyrillic(text);
+}

package/src/types.js

@@ -0,0 +1,58 @@
+/**
+ * @typedef {Object} NameDayEntry
+ * @property {string} name - Primary name (canonical form, Cyrillic)
+ * @property {string[]} variants - Variant forms, diminutives, female forms
+ * @property {string[]} latin - Latin transliterations of name + variants
+ * @property {number} month - Month (1-12), 0 for moveable dates
+ * @property {number} day - Day (1-31), 0 for moveable dates
+ * @property {string} holiday - Holiday name in Bulgarian
+ * @property {string} holidayLatin - Holiday name in Latin transliteration
+ * @property {'orthodox'|'folk'|'both'} tradition - Tradition source
+ * @property {string|null} moveable - null for fixed dates, offset string for moveable (e.g. "easter", "easter-7", "easter+39")
+ */
+
+/**
+ * @typedef {Object} NameDayResult
+ * @property {string} name - Primary name (Cyrillic)
+ * @property {number} month - Month (1-12)
+ * @property {number} day - Day (1-31)
+ * @property {string} holiday - Holiday name in Bulgarian
+ * @property {string} holidayLatin - Holiday name in Latin transliteration
+ * @property {'orthodox'|'folk'|'both'} tradition - Tradition source
+ * @property {string[]} variants - All variant forms
+ * @property {boolean} isMoveable - Whether this is a moveable feast date
+ */
+
+/**
+ * @typedef {Object} MoveableHoliday
+ * @property {string} id - Unique identifier (e.g. "easter", "tsvetnitsa")
+ * @property {string} holiday - Holiday name in Bulgarian
+ * @property {string} holidayLatin - Holiday name in Latin transliteration
+ * @property {number} offsetFromEaster - Days offset from Easter (negative = before, positive = after, 0 = Easter itself)
+ * @property {'orthodox'|'folk'|'both'} tradition - Tradition source
+ * @property {MoveableNameEntry[]} entries - Name entries for this holiday
+ */
+
+/**
+ * @typedef {Object} MoveableNameEntry
+ * @property {string} name - Primary name (Cyrillic)
+ * @property {string[]} variants - Variant forms
+ * @property {string[]} latin - Latin transliterations
+ */
+
+/**
+ * @typedef {Object} UpcomingNameDay
+ * @property {number} month - Month (1-12)
+ * @property {number} day - Day (1-31)
+ * @property {string} holiday - Holiday name in Bulgarian
+ * @property {string[]} names - All celebrating names (primary + variants)
+ */
+
+/**
+ * @typedef {Object} SearchResult
+ * @property {string} name - Name found (Cyrillic)
+ * @property {string} date - Date string "MM-DD"
+ * @property {string} holiday - Holiday name
+ */
+
+export {};

package/src/upcoming.js

@@ -0,0 +1,64 @@
+/** @typedef {import('./types.js').UpcomingNameDay} UpcomingNameDay */
+
+import { getIndex } from './data/nameDays.js';
+
+/**
+ * Get upcoming name days within a given number of days.
+ * Handles year boundaries (December → January).
+ *
+ * @param {number} days - Number of days to look ahead
+ * @param {Date} [startDate] - Start date (default: today)
+ * @returns {UpcomingNameDay[]} Sorted by date
+ */
+export function getUpcomingNameDays(days, startDate) {
+  if (!days || typeof days !== 'number' || days < 1) return [];
+
+  const start = startDate instanceof Date && !Number.isNaN(startDate.getTime())
+    ? startDate
+    : new Date();
+
+  /** @type {UpcomingNameDay[]} */
+  const results = [];
+
+  for (let i = 0; i < days; i++) {
+    const current = new Date(start);
+    current.setDate(current.getDate() + i);
+
+    const month = current.getMonth() + 1;
+    const day = current.getDate();
+    const year = current.getFullYear();
+    const dateKey = `${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+
+    const idx = getIndex(year);
+    const entries = idx.byDate.get(dateKey);
+
+    if (!entries || entries.length === 0) continue;
+
+    // Collect all names for this date, grouped by holiday
+    /** @type {Map<string, {holiday: string, names: string[]}>} */
+    const byHoliday = new Map();
+
+    for (const entry of entries) {
+      const key = entry.holiday;
+      if (!byHoliday.has(key)) {
+        byHoliday.set(key, { holiday: entry.holiday, names: [] });
+      }
+      const group = byHoliday.get(key);
+      group.names.push(entry.name);
+      for (const variant of entry.variants) {
+        group.names.push(variant);
+      }
+    }
+
+    for (const group of byHoliday.values()) {
+      results.push({
+        month,
+        day,
+        holiday: group.holiday,
+        names: [...new Set(group.names)],
+      });
+    }
+  }
+
+  return results;
+}