1013 lines
29 KiB
JavaScript
1013 lines
29 KiB
JavaScript
/* ui-calendar.js — Month and celestial holiday browser */
|
||
(function () {
|
||
"use strict";
|
||
|
||
const { getTarotCardDisplayName, getTarotCardSearchAliases } = window.TarotCardImages || {};
|
||
const calendarDatesUi = window.TarotCalendarDates || {};
|
||
const calendarDetailUi = window.TarotCalendarDetail || {};
|
||
const {
|
||
addDays,
|
||
buildSignDateBounds,
|
||
formatCalendarDateFromGregorian,
|
||
formatDateLabel,
|
||
formatGregorianReferenceDate,
|
||
formatIsoDate,
|
||
getDaysInMonth,
|
||
getGregorianMonthStartDate,
|
||
getGregorianReferenceDateForCalendarMonth,
|
||
getMonthStartWeekday,
|
||
intersectDateRanges,
|
||
isMonthDayInRange,
|
||
isoToDateAtNoon,
|
||
normalizeCalendarText,
|
||
parseDayRangeFromText,
|
||
parseMonthDayStartToken,
|
||
parseMonthDayToken,
|
||
parseMonthDayTokensFromText,
|
||
parseMonthRange,
|
||
resolveCalendarDayToGregorian,
|
||
resolveHolidayGregorianDate
|
||
} = calendarDatesUi;
|
||
|
||
const state = {
|
||
initialized: false,
|
||
referenceData: null,
|
||
magickDataset: null,
|
||
selectedCalendar: "gregorian",
|
||
calendarData: {},
|
||
months: [],
|
||
filteredMonths: [],
|
||
holidays: [],
|
||
calendarHolidays: [],
|
||
selectedMonthId: null,
|
||
searchQuery: "",
|
||
selectedYear: new Date().getFullYear(),
|
||
selectedDayMonthId: null,
|
||
selectedDayCalendarId: null,
|
||
selectedDayEntries: [],
|
||
planetsById: new Map(),
|
||
signsById: new Map(),
|
||
godsById: new Map(),
|
||
hebrewById: new Map(),
|
||
dayLinksCache: new Map()
|
||
};
|
||
|
||
const TAROT_TRUMP_NUMBER_BY_NAME = {
|
||
"the fool": 0,
|
||
fool: 0,
|
||
"the magus": 1,
|
||
magus: 1,
|
||
magician: 1,
|
||
"the high priestess": 2,
|
||
"high priestess": 2,
|
||
"the empress": 3,
|
||
empress: 3,
|
||
"the emperor": 4,
|
||
emperor: 4,
|
||
"the hierophant": 5,
|
||
hierophant: 5,
|
||
"the lovers": 6,
|
||
lovers: 6,
|
||
"the chariot": 7,
|
||
chariot: 7,
|
||
strength: 8,
|
||
lust: 8,
|
||
"the hermit": 9,
|
||
hermit: 9,
|
||
fortune: 10,
|
||
"wheel of fortune": 10,
|
||
justice: 11,
|
||
"the hanged man": 12,
|
||
"hanged man": 12,
|
||
death: 13,
|
||
temperance: 14,
|
||
art: 14,
|
||
"the devil": 15,
|
||
devil: 15,
|
||
"the tower": 16,
|
||
tower: 16,
|
||
"the star": 17,
|
||
star: 17,
|
||
"the moon": 18,
|
||
moon: 18,
|
||
"the sun": 19,
|
||
sun: 19,
|
||
aeon: 20,
|
||
judgement: 20,
|
||
judgment: 20,
|
||
universe: 21,
|
||
world: 21,
|
||
"the world": 21
|
||
};
|
||
|
||
function normalizeText(value) {
|
||
return String(value || "").trim();
|
||
}
|
||
|
||
function normalizeSearchValue(value) {
|
||
return normalizeText(value).toLowerCase();
|
||
}
|
||
|
||
function cap(value) {
|
||
const text = normalizeText(value);
|
||
return text ? text.charAt(0).toUpperCase() + text.slice(1) : text;
|
||
}
|
||
|
||
function normalizeTarotName(value) {
|
||
return normalizeText(value)
|
||
.toLowerCase()
|
||
.replace(/\s+/g, " ");
|
||
}
|
||
|
||
function resolveTarotTrumpNumber(cardName) {
|
||
const key = normalizeTarotName(cardName);
|
||
if (!key) {
|
||
return null;
|
||
}
|
||
|
||
if (Object.prototype.hasOwnProperty.call(TAROT_TRUMP_NUMBER_BY_NAME, key)) {
|
||
return TAROT_TRUMP_NUMBER_BY_NAME[key];
|
||
}
|
||
|
||
const withoutLeadingThe = key.replace(/^the\s+/, "");
|
||
if (Object.prototype.hasOwnProperty.call(TAROT_TRUMP_NUMBER_BY_NAME, withoutLeadingThe)) {
|
||
return TAROT_TRUMP_NUMBER_BY_NAME[withoutLeadingThe];
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
function getDisplayTarotName(cardName, trumpNumber) {
|
||
if (!cardName) {
|
||
return "";
|
||
}
|
||
|
||
if (typeof getTarotCardDisplayName !== "function") {
|
||
return cardName;
|
||
}
|
||
|
||
if (Number.isFinite(Number(trumpNumber))) {
|
||
return getTarotCardDisplayName(cardName, { trumpNumber: Number(trumpNumber) }) || cardName;
|
||
}
|
||
|
||
return getTarotCardDisplayName(cardName) || cardName;
|
||
}
|
||
|
||
function normalizeMinorTarotCardName(value) {
|
||
return normalizeTarotName(value)
|
||
.split(" ")
|
||
.filter(Boolean)
|
||
.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
|
||
.join(" ");
|
||
}
|
||
|
||
function normalizeDayFilterEntry(dayNumber, gregorianIso) {
|
||
const nextDayNumber = Math.trunc(Number(dayNumber));
|
||
const nextIso = normalizeText(gregorianIso);
|
||
if (!Number.isFinite(nextDayNumber) || nextDayNumber <= 0 || !nextIso) {
|
||
return null;
|
||
}
|
||
|
||
return {
|
||
dayNumber: nextDayNumber,
|
||
gregorianIso: nextIso
|
||
};
|
||
}
|
||
|
||
function sortDayFilterEntries(entries) {
|
||
const deduped = new Map();
|
||
(Array.isArray(entries) ? entries : []).forEach((entry) => {
|
||
const normalized = normalizeDayFilterEntry(entry?.dayNumber, entry?.gregorianIso);
|
||
if (normalized) {
|
||
deduped.set(normalized.dayNumber, normalized);
|
||
}
|
||
});
|
||
|
||
return [...deduped.values()].sort((left, right) => left.dayNumber - right.dayNumber);
|
||
}
|
||
|
||
function getElements() {
|
||
return {
|
||
monthListEl: document.getElementById("calendar-month-list"),
|
||
monthCountEl: document.getElementById("calendar-month-count"),
|
||
listTitleEl: document.getElementById("calendar-list-title"),
|
||
calendarTypeEl: document.getElementById("calendar-type-select"),
|
||
calendarYearWrapEl: document.getElementById("calendar-year-wrap"),
|
||
yearInputEl: document.getElementById("calendar-year-input"),
|
||
searchInputEl: document.getElementById("calendar-search-input"),
|
||
searchClearEl: document.getElementById("calendar-search-clear"),
|
||
detailNameEl: document.getElementById("calendar-detail-name"),
|
||
detailSubEl: document.getElementById("calendar-detail-sub"),
|
||
detailBodyEl: document.getElementById("calendar-detail-body")
|
||
};
|
||
}
|
||
|
||
function ensureDayFilterContext(month) {
|
||
if (!month) {
|
||
return;
|
||
}
|
||
|
||
const sameContext = state.selectedDayMonthId === month.id
|
||
&& state.selectedDayCalendarId === state.selectedCalendar;
|
||
|
||
if (!sameContext) {
|
||
state.selectedDayMonthId = month.id;
|
||
state.selectedDayCalendarId = state.selectedCalendar;
|
||
state.selectedDayEntries = [];
|
||
}
|
||
}
|
||
|
||
function clearSelectedDayFilter() {
|
||
state.selectedDayMonthId = null;
|
||
state.selectedDayCalendarId = null;
|
||
state.selectedDayEntries = [];
|
||
}
|
||
|
||
function toggleDayFilterEntry(month, dayNumber, gregorianIso) {
|
||
ensureDayFilterContext(month);
|
||
|
||
const next = normalizeDayFilterEntry(dayNumber, gregorianIso);
|
||
if (!next) {
|
||
return;
|
||
}
|
||
|
||
const entries = [...state.selectedDayEntries];
|
||
const existingIndex = entries.findIndex((entry) => entry.dayNumber === next.dayNumber);
|
||
if (existingIndex >= 0) {
|
||
entries.splice(existingIndex, 1);
|
||
} else {
|
||
entries.push(next);
|
||
}
|
||
|
||
state.selectedDayEntries = sortDayFilterEntries(entries);
|
||
}
|
||
|
||
function toggleDayRangeFilter(month, startDay, endDay) {
|
||
ensureDayFilterContext(month);
|
||
|
||
const start = Math.trunc(Number(startDay));
|
||
const end = Math.trunc(Number(endDay));
|
||
if (!Number.isFinite(start) || !Number.isFinite(end) || start <= 0 || end <= 0) {
|
||
return;
|
||
}
|
||
|
||
const minDay = Math.min(start, end);
|
||
const maxDay = Math.max(start, end);
|
||
const rows = getMonthDayLinkRows(month)
|
||
.filter((row) => row.isResolved && row.day >= minDay && row.day <= maxDay)
|
||
.map((row) => normalizeDayFilterEntry(row.day, row.gregorianDate))
|
||
.filter(Boolean);
|
||
|
||
if (!rows.length) {
|
||
return;
|
||
}
|
||
|
||
const existingSet = new Set(state.selectedDayEntries.map((entry) => entry.dayNumber));
|
||
const allSelected = rows.every((row) => existingSet.has(row.dayNumber));
|
||
|
||
if (allSelected) {
|
||
const removeSet = new Set(rows.map((row) => row.dayNumber));
|
||
state.selectedDayEntries = state.selectedDayEntries.filter((entry) => !removeSet.has(entry.dayNumber));
|
||
return;
|
||
}
|
||
|
||
rows.forEach((row) => {
|
||
if (!existingSet.has(row.dayNumber)) {
|
||
state.selectedDayEntries.push(row);
|
||
}
|
||
});
|
||
|
||
state.selectedDayEntries = sortDayFilterEntries(state.selectedDayEntries);
|
||
}
|
||
|
||
function getSelectedDayFilterContext(month) {
|
||
if (!month) {
|
||
return null;
|
||
}
|
||
if (state.selectedDayMonthId !== month.id) {
|
||
return null;
|
||
}
|
||
if (state.selectedDayCalendarId !== state.selectedCalendar) {
|
||
return null;
|
||
}
|
||
if (!Array.isArray(state.selectedDayEntries) || !state.selectedDayEntries.length) {
|
||
return null;
|
||
}
|
||
|
||
const entries = state.selectedDayEntries
|
||
.map((entry) => {
|
||
const normalized = normalizeDayFilterEntry(entry.dayNumber, entry.gregorianIso);
|
||
if (!normalized) {
|
||
return null;
|
||
}
|
||
return {
|
||
...normalized,
|
||
gregorianDate: isoToDateAtNoon(normalized.gregorianIso)
|
||
};
|
||
})
|
||
.filter(Boolean);
|
||
|
||
if (!entries.length) {
|
||
return null;
|
||
}
|
||
|
||
return {
|
||
entries,
|
||
dayNumbers: new Set(entries.map((entry) => entry.dayNumber))
|
||
};
|
||
}
|
||
|
||
function buildDecanWindow(sign, decanIndex) {
|
||
const bounds = buildSignDateBounds(sign);
|
||
const index = Number(decanIndex);
|
||
if (!bounds || !Number.isFinite(index)) {
|
||
return null;
|
||
}
|
||
|
||
const start = addDays(bounds.start, (index - 1) * 10);
|
||
const nominalEnd = addDays(start, 9);
|
||
const end = nominalEnd.getTime() > bounds.end.getTime() ? bounds.end : nominalEnd;
|
||
|
||
return {
|
||
start,
|
||
end,
|
||
label: `${formatDateLabel(start)}–${formatDateLabel(end)}`
|
||
};
|
||
}
|
||
|
||
function listMonthNumbersBetween(start, end) {
|
||
const result = [];
|
||
const seen = new Set();
|
||
const cursor = new Date(start.getFullYear(), start.getMonth(), 1);
|
||
const limit = new Date(end.getFullYear(), end.getMonth(), 1);
|
||
|
||
while (cursor.getTime() <= limit.getTime()) {
|
||
const monthNo = cursor.getMonth() + 1;
|
||
if (!seen.has(monthNo)) {
|
||
seen.add(monthNo);
|
||
result.push(monthNo);
|
||
}
|
||
cursor.setMonth(cursor.getMonth() + 1);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
function buildDecanTarotRowsForMonth(month) {
|
||
const monthOrder = Number(month?.order);
|
||
if (!Number.isFinite(monthOrder)) {
|
||
return [];
|
||
}
|
||
|
||
const rows = [];
|
||
const seen = new Set();
|
||
const decansBySign = state.referenceData?.decansBySign || {};
|
||
|
||
Object.entries(decansBySign).forEach(([signId, decans]) => {
|
||
const sign = state.signsById.get(signId);
|
||
if (!sign || !Array.isArray(decans)) {
|
||
return;
|
||
}
|
||
|
||
decans.forEach((decan) => {
|
||
const window = buildDecanWindow(sign, decan?.index);
|
||
if (!window) {
|
||
return;
|
||
}
|
||
|
||
const monthsTouched = listMonthNumbersBetween(window.start, window.end);
|
||
if (!monthsTouched.includes(monthOrder)) {
|
||
return;
|
||
}
|
||
|
||
const cardName = normalizeMinorTarotCardName(decan?.tarotMinorArcana);
|
||
if (!cardName) {
|
||
return;
|
||
}
|
||
|
||
const key = `${cardName}|${signId}|${decan.index}`;
|
||
if (seen.has(key)) {
|
||
return;
|
||
}
|
||
seen.add(key);
|
||
|
||
const startDegree = (Number(decan.index) - 1) * 10;
|
||
const endDegree = startDegree + 10;
|
||
const signName = sign?.name?.en || sign?.name || signId;
|
||
|
||
rows.push({
|
||
cardName,
|
||
signId,
|
||
signName,
|
||
signSymbol: sign?.symbol || "",
|
||
decanIndex: Number(decan.index),
|
||
startDegree,
|
||
endDegree,
|
||
startTime: window.start.getTime(),
|
||
endTime: window.end.getTime(),
|
||
startMonth: window.start.getMonth() + 1,
|
||
startDay: window.start.getDate(),
|
||
endMonth: window.end.getMonth() + 1,
|
||
endDay: window.end.getDate(),
|
||
dateRange: window.label
|
||
});
|
||
});
|
||
});
|
||
|
||
rows.sort((left, right) => {
|
||
if (left.startTime !== right.startTime) {
|
||
return left.startTime - right.startTime;
|
||
}
|
||
if (left.decanIndex !== right.decanIndex) {
|
||
return left.decanIndex - right.decanIndex;
|
||
}
|
||
return left.cardName.localeCompare(right.cardName);
|
||
});
|
||
|
||
return rows;
|
||
}
|
||
|
||
function buildPlanetMap(planetsObj) {
|
||
const map = new Map();
|
||
if (!planetsObj || typeof planetsObj !== "object") {
|
||
return map;
|
||
}
|
||
|
||
Object.values(planetsObj).forEach((planet) => {
|
||
if (planet?.id) {
|
||
map.set(planet.id, planet);
|
||
}
|
||
});
|
||
|
||
return map;
|
||
}
|
||
|
||
function buildSignsMap(signs) {
|
||
const map = new Map();
|
||
if (!Array.isArray(signs)) {
|
||
return map;
|
||
}
|
||
|
||
signs.forEach((sign) => {
|
||
if (sign?.id) {
|
||
map.set(sign.id, sign);
|
||
}
|
||
});
|
||
|
||
return map;
|
||
}
|
||
|
||
function buildGodsMap(magickDataset) {
|
||
const gods = magickDataset?.grouped?.gods?.gods;
|
||
const map = new Map();
|
||
if (!Array.isArray(gods)) {
|
||
return map;
|
||
}
|
||
|
||
gods.forEach((god) => {
|
||
if (god?.id) {
|
||
map.set(god.id, god);
|
||
}
|
||
});
|
||
|
||
return map;
|
||
}
|
||
|
||
function findGodIdByName(name) {
|
||
if (!name) {
|
||
return null;
|
||
}
|
||
|
||
const normalized = normalizeText(name).toLowerCase().replace(/^the\s+/, "");
|
||
for (const [id, god] of state.godsById) {
|
||
const godName = normalizeText(god?.name).toLowerCase().replace(/^the\s+/, "");
|
||
if (godName === normalized || id.toLowerCase() === normalized) {
|
||
return id;
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
function buildHebrewMap(magickDataset) {
|
||
const map = new Map();
|
||
const letters = magickDataset?.grouped?.alphabets?.hebrew;
|
||
if (!Array.isArray(letters)) {
|
||
return map;
|
||
}
|
||
|
||
letters.forEach((letter) => {
|
||
if (letter?.hebrewLetterId) {
|
||
map.set(letter.hebrewLetterId, letter);
|
||
}
|
||
});
|
||
|
||
return map;
|
||
}
|
||
|
||
function sortMonths(months) {
|
||
return [...months].sort((left, right) => Number(left?.order || 0) - Number(right?.order || 0));
|
||
}
|
||
|
||
function getSelectedMonth() {
|
||
return state.months.find((month) => month.id === state.selectedMonthId) || null;
|
||
}
|
||
|
||
function getMonthSubtitle(month) {
|
||
if (state.selectedCalendar === "hebrew" || state.selectedCalendar === "islamic") {
|
||
const native = month.nativeName ? ` · ${month.nativeName}` : "";
|
||
const days = month.days ? ` · ${month.days} days` : "";
|
||
return `${month.season || ""}${native}${days}`;
|
||
}
|
||
if (state.selectedCalendar === "wheel-of-year") {
|
||
return [month.date, month.type, month.season].filter(Boolean).join(" · ");
|
||
}
|
||
return parseMonthRange(month);
|
||
}
|
||
|
||
function getMonthDayLinkRows(month) {
|
||
const cacheKey = `${state.selectedCalendar}|${state.selectedYear}|${month?.id || ""}`;
|
||
if (state.dayLinksCache.has(cacheKey)) {
|
||
return state.dayLinksCache.get(cacheKey);
|
||
}
|
||
|
||
let dayCount = null;
|
||
if (state.selectedCalendar === "gregorian") {
|
||
dayCount = getDaysInMonth(state.selectedYear, Number(month?.order));
|
||
} else if (state.selectedCalendar === "hebrew" || state.selectedCalendar === "islamic") {
|
||
const baseDays = Number(month?.days);
|
||
const variantDays = Number(month?.daysVariant);
|
||
if (Number.isFinite(baseDays) && Number.isFinite(variantDays)) {
|
||
dayCount = Math.max(Math.trunc(baseDays), Math.trunc(variantDays));
|
||
} else if (Number.isFinite(baseDays)) {
|
||
dayCount = Math.trunc(baseDays);
|
||
} else if (Number.isFinite(variantDays)) {
|
||
dayCount = Math.trunc(variantDays);
|
||
}
|
||
}
|
||
|
||
if (!Number.isFinite(dayCount) || dayCount <= 0) {
|
||
state.dayLinksCache.set(cacheKey, []);
|
||
return [];
|
||
}
|
||
|
||
const rows = [];
|
||
for (let day = 1; day <= dayCount; day += 1) {
|
||
const gregorianDate = resolveCalendarDayToGregorian(month, day);
|
||
rows.push({
|
||
day,
|
||
gregorianDate: formatIsoDate(gregorianDate),
|
||
isResolved: Boolean(gregorianDate && !Number.isNaN(gregorianDate.getTime()))
|
||
});
|
||
}
|
||
|
||
state.dayLinksCache.set(cacheKey, rows);
|
||
return rows;
|
||
}
|
||
|
||
function renderList(elements) {
|
||
const { monthListEl, monthCountEl, listTitleEl } = elements;
|
||
if (!monthListEl) {
|
||
return;
|
||
}
|
||
|
||
monthListEl.innerHTML = "";
|
||
|
||
state.filteredMonths.forEach((month) => {
|
||
const isSelected = month.id === state.selectedMonthId;
|
||
const itemEl = document.createElement("div");
|
||
itemEl.className = `planet-list-item${isSelected ? " is-selected" : ""}`;
|
||
itemEl.setAttribute("role", "option");
|
||
itemEl.setAttribute("aria-selected", isSelected ? "true" : "false");
|
||
itemEl.dataset.monthId = month.id;
|
||
itemEl.innerHTML = `
|
||
<div class="planet-list-name">${month.name || month.id}</div>
|
||
<div class="planet-list-meta">${getMonthSubtitle(month)}</div>
|
||
`;
|
||
itemEl.addEventListener("click", () => {
|
||
selectByMonthId(month.id, elements);
|
||
});
|
||
monthListEl.appendChild(itemEl);
|
||
});
|
||
|
||
if (monthCountEl) {
|
||
monthCountEl.textContent = state.searchQuery
|
||
? `${state.filteredMonths.length} of ${state.months.length} months`
|
||
: `${state.months.length} months`;
|
||
}
|
||
|
||
if (listTitleEl) {
|
||
listTitleEl.textContent = "Calendar > Months";
|
||
}
|
||
}
|
||
|
||
function associationSearchText(associations) {
|
||
if (!associations || typeof associations !== "object") {
|
||
return "";
|
||
}
|
||
|
||
const tarotAliases = associations.tarotCard && typeof getTarotCardSearchAliases === "function"
|
||
? getTarotCardSearchAliases(associations.tarotCard, { trumpNumber: associations.tarotTrumpNumber })
|
||
: [];
|
||
|
||
return [
|
||
associations.planetId,
|
||
associations.zodiacSignId,
|
||
associations.numberValue,
|
||
associations.tarotCard,
|
||
associations.tarotTrumpNumber,
|
||
...tarotAliases,
|
||
associations.godId,
|
||
associations.godName,
|
||
associations.hebrewLetterId,
|
||
associations.kabbalahPathNumber,
|
||
associations.iChingPlanetaryInfluence
|
||
].filter(Boolean).join(" ");
|
||
}
|
||
|
||
function eventSearchText(event) {
|
||
return normalizeSearchValue([
|
||
event?.name,
|
||
event?.date,
|
||
event?.dateRange,
|
||
event?.description,
|
||
associationSearchText(event?.associations)
|
||
].filter(Boolean).join(" "));
|
||
}
|
||
|
||
function holidaySearchText(holiday) {
|
||
return normalizeSearchValue([
|
||
holiday?.name,
|
||
holiday?.kind,
|
||
holiday?.date,
|
||
holiday?.dateRange,
|
||
holiday?.dateText,
|
||
holiday?.monthDayStart,
|
||
holiday?.calendarId,
|
||
holiday?.description,
|
||
associationSearchText(holiday?.associations)
|
||
].filter(Boolean).join(" "));
|
||
}
|
||
|
||
function buildHolidayList(month) {
|
||
const calendarId = state.selectedCalendar;
|
||
const monthOrder = Number(month?.order);
|
||
|
||
const fromRepo = state.calendarHolidays.filter((holiday) => {
|
||
const holidayCalendarId = normalizeText(holiday?.calendarId).toLowerCase();
|
||
if (holidayCalendarId !== calendarId) {
|
||
return false;
|
||
}
|
||
|
||
const isDirectMonthMatch = normalizeText(holiday?.monthId).toLowerCase() === normalizeText(month?.id).toLowerCase();
|
||
if (isDirectMonthMatch) {
|
||
return true;
|
||
}
|
||
|
||
if (calendarId === "gregorian" && holiday?.dateRule && Number.isFinite(monthOrder)) {
|
||
const computedDate = resolveHolidayGregorianDate(holiday);
|
||
return computedDate instanceof Date
|
||
&& !Number.isNaN(computedDate.getTime())
|
||
&& (computedDate.getMonth() + 1) === Math.trunc(monthOrder);
|
||
}
|
||
|
||
return false;
|
||
});
|
||
|
||
if (fromRepo.length) {
|
||
return [...fromRepo].sort((left, right) => {
|
||
const leftDate = resolveHolidayGregorianDate(left);
|
||
const rightDate = resolveHolidayGregorianDate(right);
|
||
const leftDay = Number.isFinite(Number(left?.day))
|
||
? Number(left.day)
|
||
: ((leftDate instanceof Date && !Number.isNaN(leftDate.getTime())) ? leftDate.getDate() : NaN);
|
||
const rightDay = Number.isFinite(Number(right?.day))
|
||
? Number(right.day)
|
||
: ((rightDate instanceof Date && !Number.isNaN(rightDate.getTime())) ? rightDate.getDate() : NaN);
|
||
if (Number.isFinite(leftDay) && Number.isFinite(rightDay) && leftDay !== rightDay) {
|
||
return leftDay - rightDay;
|
||
}
|
||
return normalizeText(left?.name).localeCompare(normalizeText(right?.name));
|
||
});
|
||
}
|
||
|
||
const seen = new Set();
|
||
const ordered = [];
|
||
|
||
(month?.holidayIds || []).forEach((holidayId) => {
|
||
const holiday = state.holidays.find((item) => item.id === holidayId);
|
||
if (holiday && !seen.has(holiday.id)) {
|
||
seen.add(holiday.id);
|
||
ordered.push(holiday);
|
||
}
|
||
});
|
||
|
||
state.holidays.forEach((holiday) => {
|
||
if (holiday?.monthId === month.id && !seen.has(holiday.id)) {
|
||
seen.add(holiday.id);
|
||
ordered.push(holiday);
|
||
}
|
||
});
|
||
|
||
return ordered;
|
||
}
|
||
|
||
function buildMonthSearchText(month) {
|
||
const monthHolidays = buildHolidayList(month);
|
||
const holidayText = monthHolidays.map((holiday) => holidaySearchText(holiday)).join(" ");
|
||
|
||
if (state.selectedCalendar === "gregorian") {
|
||
const events = Array.isArray(month?.events) ? month.events : [];
|
||
return normalizeSearchValue([
|
||
month?.name,
|
||
month?.id,
|
||
month?.start,
|
||
month?.end,
|
||
month?.coreTheme,
|
||
month?.seasonNorth,
|
||
month?.seasonSouth,
|
||
associationSearchText(month?.associations),
|
||
events.map((event) => eventSearchText(event)).join(" "),
|
||
holidayText
|
||
].filter(Boolean).join(" "));
|
||
}
|
||
|
||
const wheelAssocText = month?.associations
|
||
? [
|
||
Array.isArray(month.associations.themes) ? month.associations.themes.join(" ") : "",
|
||
Array.isArray(month.associations.deities) ? month.associations.deities.join(" ") : "",
|
||
month.associations.element,
|
||
month.associations.direction
|
||
].filter(Boolean).join(" ")
|
||
: "";
|
||
|
||
return normalizeSearchValue([
|
||
month?.name,
|
||
month?.id,
|
||
month?.nativeName,
|
||
month?.meaning,
|
||
month?.season,
|
||
month?.description,
|
||
month?.zodiacSign,
|
||
month?.tribe,
|
||
month?.element,
|
||
month?.type,
|
||
month?.date,
|
||
month?.hebrewLetter,
|
||
holidayText,
|
||
wheelAssocText
|
||
].filter(Boolean).join(" "));
|
||
}
|
||
|
||
function matchesSearch(searchText) {
|
||
if (!state.searchQuery) {
|
||
return true;
|
||
}
|
||
return searchText.includes(state.searchQuery);
|
||
}
|
||
|
||
function syncSearchControls(elements) {
|
||
if (elements.searchInputEl) {
|
||
elements.searchInputEl.value = state.searchQuery;
|
||
}
|
||
if (elements.searchClearEl) {
|
||
elements.searchClearEl.disabled = !state.searchQuery;
|
||
}
|
||
}
|
||
|
||
function renderDetail(elements) {
|
||
calendarDetailUi.renderDetail?.(elements);
|
||
}
|
||
|
||
function applySearchFilter(elements) {
|
||
state.filteredMonths = state.searchQuery
|
||
? state.months.filter((month) => matchesSearch(buildMonthSearchText(month)))
|
||
: [...state.months];
|
||
|
||
if (!state.filteredMonths.some((month) => month.id === state.selectedMonthId)) {
|
||
state.selectedMonthId = state.filteredMonths[0]?.id || null;
|
||
}
|
||
|
||
syncSearchControls(elements);
|
||
renderList(elements);
|
||
renderDetail(elements);
|
||
}
|
||
|
||
function selectByMonthId(monthId, elements = getElements()) {
|
||
const target = state.months.find((month) => month.id === monthId);
|
||
if (!target) {
|
||
return false;
|
||
}
|
||
|
||
if (state.searchQuery && !state.filteredMonths.some((month) => month.id === target.id)) {
|
||
state.searchQuery = "";
|
||
state.filteredMonths = [...state.months];
|
||
}
|
||
|
||
if (state.selectedMonthId !== target.id) {
|
||
clearSelectedDayFilter();
|
||
}
|
||
|
||
state.selectedMonthId = target.id;
|
||
syncSearchControls(elements);
|
||
renderList(elements);
|
||
renderDetail(elements);
|
||
return true;
|
||
}
|
||
|
||
function selectCalendarType(calendarId, elements = getElements()) {
|
||
if (!state.calendarData || !Array.isArray(state.calendarData[calendarId])) {
|
||
return false;
|
||
}
|
||
|
||
if (elements.calendarTypeEl) {
|
||
elements.calendarTypeEl.value = calendarId;
|
||
}
|
||
|
||
loadCalendarType(calendarId, elements);
|
||
return true;
|
||
}
|
||
|
||
function bindYearInput(elements) {
|
||
if (!elements.yearInputEl) {
|
||
return;
|
||
}
|
||
|
||
elements.yearInputEl.value = String(state.selectedYear);
|
||
elements.yearInputEl.addEventListener("change", () => {
|
||
const nextYear = Number(elements.yearInputEl.value);
|
||
if (!Number.isFinite(nextYear)) {
|
||
elements.yearInputEl.value = String(state.selectedYear);
|
||
return;
|
||
}
|
||
|
||
state.selectedYear = Math.min(2500, Math.max(1900, Math.round(nextYear)));
|
||
elements.yearInputEl.value = String(state.selectedYear);
|
||
state.dayLinksCache = new Map();
|
||
clearSelectedDayFilter();
|
||
renderDetail(elements);
|
||
});
|
||
}
|
||
|
||
function bindSearchInput(elements) {
|
||
if (elements.searchInputEl) {
|
||
elements.searchInputEl.addEventListener("input", () => {
|
||
state.searchQuery = normalizeSearchValue(elements.searchInputEl.value);
|
||
applySearchFilter(elements);
|
||
});
|
||
}
|
||
|
||
if (elements.searchClearEl && elements.searchInputEl) {
|
||
elements.searchClearEl.addEventListener("click", () => {
|
||
state.searchQuery = "";
|
||
elements.searchInputEl.value = "";
|
||
applySearchFilter(elements);
|
||
elements.searchInputEl.focus();
|
||
});
|
||
}
|
||
}
|
||
|
||
function loadCalendarType(calendarId, elements) {
|
||
const months = state.calendarData[calendarId];
|
||
if (!Array.isArray(months)) {
|
||
return;
|
||
}
|
||
|
||
state.selectedCalendar = calendarId;
|
||
state.dayLinksCache = new Map();
|
||
clearSelectedDayFilter();
|
||
state.months = sortMonths(months);
|
||
state.filteredMonths = [...state.months];
|
||
state.selectedMonthId = state.months[0]?.id || null;
|
||
state.searchQuery = "";
|
||
|
||
if (elements.calendarYearWrapEl) {
|
||
elements.calendarYearWrapEl.hidden = false;
|
||
}
|
||
|
||
syncSearchControls(elements);
|
||
applySearchFilter(elements);
|
||
}
|
||
|
||
function bindCalendarTypeSelect(elements) {
|
||
if (!elements.calendarTypeEl) {
|
||
return;
|
||
}
|
||
|
||
elements.calendarTypeEl.value = state.selectedCalendar;
|
||
elements.calendarTypeEl.addEventListener("change", () => {
|
||
loadCalendarType(String(elements.calendarTypeEl.value || "gregorian"), elements);
|
||
});
|
||
}
|
||
|
||
function ensureCalendarSection(referenceData, magickDataset) {
|
||
if (!referenceData) {
|
||
return;
|
||
}
|
||
|
||
calendarDatesUi.init?.({
|
||
getSelectedYear: () => state.selectedYear,
|
||
getSelectedCalendar: () => state.selectedCalendar,
|
||
getIslamicMonths: () => state.calendarData?.islamic || []
|
||
});
|
||
|
||
calendarDetailUi.init?.({
|
||
getState: () => state,
|
||
getElements,
|
||
getSelectedMonth,
|
||
getSelectedDayFilterContext,
|
||
clearSelectedDayFilter,
|
||
toggleDayFilterEntry,
|
||
toggleDayRangeFilter,
|
||
getMonthSubtitle,
|
||
getMonthDayLinkRows,
|
||
buildDecanTarotRowsForMonth,
|
||
buildHolidayList,
|
||
matchesSearch,
|
||
eventSearchText,
|
||
holidaySearchText,
|
||
getDisplayTarotName,
|
||
cap,
|
||
formatGregorianReferenceDate,
|
||
getDaysInMonth,
|
||
getMonthStartWeekday,
|
||
getGregorianMonthStartDate,
|
||
formatCalendarDateFromGregorian,
|
||
parseMonthDayToken,
|
||
parseMonthDayTokensFromText,
|
||
parseMonthDayStartToken,
|
||
parseDayRangeFromText,
|
||
parseMonthRange,
|
||
formatIsoDate,
|
||
resolveHolidayGregorianDate,
|
||
isMonthDayInRange,
|
||
intersectDateRanges,
|
||
getGregorianReferenceDateForCalendarMonth,
|
||
normalizeCalendarText,
|
||
findGodIdByName
|
||
});
|
||
|
||
state.referenceData = referenceData;
|
||
state.magickDataset = magickDataset || null;
|
||
state.dayLinksCache = new Map();
|
||
clearSelectedDayFilter();
|
||
state.holidays = Array.isArray(referenceData.celestialHolidays) ? referenceData.celestialHolidays : [];
|
||
state.calendarHolidays = Array.isArray(referenceData.calendarHolidays) ? referenceData.calendarHolidays : [];
|
||
state.planetsById = buildPlanetMap(referenceData.planets);
|
||
state.signsById = buildSignsMap(referenceData.signs);
|
||
state.godsById = buildGodsMap(state.magickDataset);
|
||
state.hebrewById = buildHebrewMap(state.magickDataset);
|
||
|
||
state.calendarData = {
|
||
gregorian: Array.isArray(referenceData.calendarMonths) ? referenceData.calendarMonths : [],
|
||
hebrew: Array.isArray(referenceData.hebrewCalendar?.months) ? referenceData.hebrewCalendar.months : [],
|
||
islamic: Array.isArray(referenceData.islamicCalendar?.months) ? referenceData.islamicCalendar.months : [],
|
||
"wheel-of-year": Array.isArray(referenceData.wheelOfYear?.months) ? referenceData.wheelOfYear.months : []
|
||
};
|
||
|
||
const currentCalMonths = state.calendarData[state.selectedCalendar] || state.calendarData.gregorian || [];
|
||
state.months = sortMonths(currentCalMonths);
|
||
state.filteredMonths = [...state.months];
|
||
|
||
const elements = getElements();
|
||
if (elements.calendarYearWrapEl) {
|
||
elements.calendarYearWrapEl.hidden = false;
|
||
}
|
||
|
||
if (!state.months.length) {
|
||
if (elements.detailNameEl) {
|
||
elements.detailNameEl.textContent = "Calendar";
|
||
}
|
||
if (elements.detailSubEl) {
|
||
elements.detailSubEl.textContent = "No month data available.";
|
||
}
|
||
if (elements.detailBodyEl) {
|
||
elements.detailBodyEl.innerHTML = "";
|
||
}
|
||
if (elements.monthListEl) {
|
||
elements.monthListEl.innerHTML = "";
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (!state.selectedMonthId || !state.months.some((month) => month.id === state.selectedMonthId)) {
|
||
state.selectedMonthId = state.months[0].id;
|
||
}
|
||
|
||
if (!state.initialized) {
|
||
state.initialized = true;
|
||
bindYearInput(elements);
|
||
bindSearchInput(elements);
|
||
bindCalendarTypeSelect(elements);
|
||
}
|
||
|
||
applySearchFilter(elements);
|
||
}
|
||
|
||
window.CalendarSectionUi = {
|
||
ensureCalendarSection,
|
||
selectByMonthId,
|
||
selectCalendarType
|
||
};
|
||
})();
|