2315 lines
71 KiB
JavaScript
2315 lines
71 KiB
JavaScript
|
(function () {
|
|||
|
|
const { resolveTarotCardImage, getTarotCardDisplayName, getTarotCardSearchAliases } = window.TarotCardImages || {};
|
|||
|
|
|
|||
|
|
const state = {
|
|||
|
|
initialized: false,
|
|||
|
|
cards: [],
|
|||
|
|
filteredCards: [],
|
|||
|
|
searchQuery: "",
|
|||
|
|
selectedCardId: "",
|
|||
|
|
magickDataset: null,
|
|||
|
|
referenceData: null,
|
|||
|
|
monthRefsByCardId: new Map(),
|
|||
|
|
courtCardByDecanId: new Map()
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
let tarotLightboxOverlayEl = null;
|
|||
|
|
let tarotLightboxImageEl = null;
|
|||
|
|
let tarotLightboxZoomed = false;
|
|||
|
|
|
|||
|
|
const LIGHTBOX_ZOOM_SCALE = 6.66;
|
|||
|
|
|
|||
|
|
function resetTarotLightboxZoom() {
|
|||
|
|
if (!tarotLightboxImageEl) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
tarotLightboxZoomed = false;
|
|||
|
|
tarotLightboxImageEl.style.transform = "scale(1)";
|
|||
|
|
tarotLightboxImageEl.style.transformOrigin = "center center";
|
|||
|
|
tarotLightboxImageEl.style.cursor = "zoom-in";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function updateTarotLightboxZoomOrigin(clientX, clientY) {
|
|||
|
|
if (!tarotLightboxZoomed || !tarotLightboxImageEl) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const rect = tarotLightboxImageEl.getBoundingClientRect();
|
|||
|
|
if (!rect.width || !rect.height) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const x = Math.min(100, Math.max(0, ((clientX - rect.left) / rect.width) * 100));
|
|||
|
|
const y = Math.min(100, Math.max(0, ((clientY - rect.top) / rect.height) * 100));
|
|||
|
|
tarotLightboxImageEl.style.transformOrigin = `${x}% ${y}%`;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function isTarotLightboxPointOnCard(clientX, clientY) {
|
|||
|
|
if (!tarotLightboxImageEl) {
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const rect = tarotLightboxImageEl.getBoundingClientRect();
|
|||
|
|
const naturalWidth = tarotLightboxImageEl.naturalWidth;
|
|||
|
|
const naturalHeight = tarotLightboxImageEl.naturalHeight;
|
|||
|
|
|
|||
|
|
if (!rect.width || !rect.height || !naturalWidth || !naturalHeight) {
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const frameAspect = rect.width / rect.height;
|
|||
|
|
const imageAspect = naturalWidth / naturalHeight;
|
|||
|
|
|
|||
|
|
let renderWidth = rect.width;
|
|||
|
|
let renderHeight = rect.height;
|
|||
|
|
if (imageAspect > frameAspect) {
|
|||
|
|
renderHeight = rect.width / imageAspect;
|
|||
|
|
} else {
|
|||
|
|
renderWidth = rect.height * imageAspect;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const left = rect.left + (rect.width - renderWidth) / 2;
|
|||
|
|
const top = rect.top + (rect.height - renderHeight) / 2;
|
|||
|
|
const right = left + renderWidth;
|
|||
|
|
const bottom = top + renderHeight;
|
|||
|
|
|
|||
|
|
return clientX >= left && clientX <= right && clientY >= top && clientY <= bottom;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function ensureTarotImageLightbox() {
|
|||
|
|
if (tarotLightboxOverlayEl && tarotLightboxImageEl) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
tarotLightboxOverlayEl = document.createElement("div");
|
|||
|
|
tarotLightboxOverlayEl.setAttribute("aria-hidden", "true");
|
|||
|
|
tarotLightboxOverlayEl.style.position = "fixed";
|
|||
|
|
tarotLightboxOverlayEl.style.inset = "0";
|
|||
|
|
tarotLightboxOverlayEl.style.background = "rgba(0, 0, 0, 0.82)";
|
|||
|
|
tarotLightboxOverlayEl.style.display = "none";
|
|||
|
|
tarotLightboxOverlayEl.style.alignItems = "center";
|
|||
|
|
tarotLightboxOverlayEl.style.justifyContent = "center";
|
|||
|
|
tarotLightboxOverlayEl.style.zIndex = "9999";
|
|||
|
|
tarotLightboxOverlayEl.style.padding = "0";
|
|||
|
|
|
|||
|
|
const image = document.createElement("img");
|
|||
|
|
image.alt = "Tarot card enlarged image";
|
|||
|
|
image.style.maxWidth = "100vw";
|
|||
|
|
image.style.maxHeight = "100vh";
|
|||
|
|
image.style.width = "100vw";
|
|||
|
|
image.style.height = "100vh";
|
|||
|
|
image.style.objectFit = "contain";
|
|||
|
|
image.style.borderRadius = "0";
|
|||
|
|
image.style.boxShadow = "none";
|
|||
|
|
image.style.border = "none";
|
|||
|
|
image.style.cursor = "zoom-in";
|
|||
|
|
image.style.transform = "scale(1)";
|
|||
|
|
image.style.transformOrigin = "center center";
|
|||
|
|
image.style.transition = "transform 120ms ease-out";
|
|||
|
|
image.style.userSelect = "none";
|
|||
|
|
|
|||
|
|
tarotLightboxImageEl = image;
|
|||
|
|
tarotLightboxOverlayEl.appendChild(image);
|
|||
|
|
|
|||
|
|
const closeLightbox = () => {
|
|||
|
|
if (!tarotLightboxOverlayEl || !tarotLightboxImageEl) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
tarotLightboxOverlayEl.style.display = "none";
|
|||
|
|
tarotLightboxOverlayEl.setAttribute("aria-hidden", "true");
|
|||
|
|
tarotLightboxImageEl.removeAttribute("src");
|
|||
|
|
resetTarotLightboxZoom();
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
tarotLightboxOverlayEl.addEventListener("click", (event) => {
|
|||
|
|
if (event.target === tarotLightboxOverlayEl) {
|
|||
|
|
closeLightbox();
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
tarotLightboxImageEl.addEventListener("click", (event) => {
|
|||
|
|
event.stopPropagation();
|
|||
|
|
if (!isTarotLightboxPointOnCard(event.clientX, event.clientY)) {
|
|||
|
|
closeLightbox();
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
if (!tarotLightboxZoomed) {
|
|||
|
|
tarotLightboxZoomed = true;
|
|||
|
|
tarotLightboxImageEl.style.transform = `scale(${LIGHTBOX_ZOOM_SCALE})`;
|
|||
|
|
tarotLightboxImageEl.style.cursor = "zoom-out";
|
|||
|
|
updateTarotLightboxZoomOrigin(event.clientX, event.clientY);
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
resetTarotLightboxZoom();
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
tarotLightboxImageEl.addEventListener("mousemove", (event) => {
|
|||
|
|
updateTarotLightboxZoomOrigin(event.clientX, event.clientY);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
tarotLightboxImageEl.addEventListener("mouseleave", () => {
|
|||
|
|
if (tarotLightboxZoomed) {
|
|||
|
|
tarotLightboxImageEl.style.transformOrigin = "center center";
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
document.addEventListener("keydown", (event) => {
|
|||
|
|
if (event.key === "Escape") {
|
|||
|
|
closeLightbox();
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
document.body.appendChild(tarotLightboxOverlayEl);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function openTarotImageLightbox(src, altText) {
|
|||
|
|
if (!src) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ensureTarotImageLightbox();
|
|||
|
|
if (!tarotLightboxOverlayEl || !tarotLightboxImageEl) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
tarotLightboxImageEl.src = src;
|
|||
|
|
tarotLightboxImageEl.alt = altText || "Tarot card enlarged image";
|
|||
|
|
resetTarotLightboxZoom();
|
|||
|
|
tarotLightboxOverlayEl.style.display = "flex";
|
|||
|
|
tarotLightboxOverlayEl.setAttribute("aria-hidden", "false");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
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
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
const MINOR_NUMBER_WORD_BY_VALUE = {
|
|||
|
|
1: "ace",
|
|||
|
|
2: "two",
|
|||
|
|
3: "three",
|
|||
|
|
4: "four",
|
|||
|
|
5: "five",
|
|||
|
|
6: "six",
|
|||
|
|
7: "seven",
|
|||
|
|
8: "eight",
|
|||
|
|
9: "nine",
|
|||
|
|
10: "ten"
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
const MINOR_TITLE_WORD_BY_VALUE = {
|
|||
|
|
1: "Ace",
|
|||
|
|
2: "Two",
|
|||
|
|
3: "Three",
|
|||
|
|
4: "Four",
|
|||
|
|
5: "Five",
|
|||
|
|
6: "Six",
|
|||
|
|
7: "Seven",
|
|||
|
|
8: "Eight",
|
|||
|
|
9: "Nine",
|
|||
|
|
10: "Ten"
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
const HOUSE_MINOR_NUMBER_BANDS = [
|
|||
|
|
[2, 3, 4],
|
|||
|
|
[5, 6, 7],
|
|||
|
|
[8, 9, 10],
|
|||
|
|
[2, 3, 4],
|
|||
|
|
[5, 6, 7],
|
|||
|
|
[8, 9, 10]
|
|||
|
|
];
|
|||
|
|
const HOUSE_LEFT_SUITS = ["Wands", "Disks", "Swords", "Cups", "Wands", "Disks"];
|
|||
|
|
const HOUSE_RIGHT_SUITS = ["Swords", "Cups", "Wands", "Disks", "Swords", "Cups"];
|
|||
|
|
const HOUSE_MIDDLE_SUITS = ["Wands", "Cups", "Swords", "Disks"];
|
|||
|
|
const HOUSE_MIDDLE_RANKS = ["Ace", "Knight", "Queen", "Prince", "Princess"];
|
|||
|
|
const HOUSE_TRUMP_ROWS = [
|
|||
|
|
[0],
|
|||
|
|
[20, 21, 12],
|
|||
|
|
[19, 10, 2, 1, 3, 16],
|
|||
|
|
[18, 17, 15, 14, 13, 9, 8, 7, 6, 5, 4],
|
|||
|
|
[11]
|
|||
|
|
];
|
|||
|
|
|
|||
|
|
const HEBREW_LETTER_ALIASES = {
|
|||
|
|
aleph: "alef",
|
|||
|
|
alef: "alef",
|
|||
|
|
heh: "he",
|
|||
|
|
he: "he",
|
|||
|
|
beth: "bet",
|
|||
|
|
bet: "bet",
|
|||
|
|
cheth: "het",
|
|||
|
|
chet: "het",
|
|||
|
|
kaph: "kaf",
|
|||
|
|
kaf: "kaf",
|
|||
|
|
peh: "pe",
|
|||
|
|
tzaddi: "tsadi",
|
|||
|
|
tzadi: "tsadi",
|
|||
|
|
tsadi: "tsadi",
|
|||
|
|
qoph: "qof",
|
|||
|
|
qof: "qof",
|
|||
|
|
taw: "tav",
|
|||
|
|
tau: "tav"
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
const CUBE_MOTHER_CONNECTOR_BY_LETTER = {
|
|||
|
|
alef: { connectorId: "above-below", connectorName: "Above ↔ Below" },
|
|||
|
|
mem: { connectorId: "east-west", connectorName: "East ↔ West" },
|
|||
|
|
shin: { connectorId: "south-north", connectorName: "South ↔ North" }
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
const ELEMENT_NAME_BY_ID = {
|
|||
|
|
water: "Water",
|
|||
|
|
fire: "Fire",
|
|||
|
|
air: "Air",
|
|||
|
|
earth: "Earth"
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
const ELEMENT_HEBREW_LETTER_BY_ID = {
|
|||
|
|
fire: "Yod",
|
|||
|
|
water: "Heh",
|
|||
|
|
air: "Vav",
|
|||
|
|
earth: "Heh"
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
const ELEMENT_HEBREW_CHAR_BY_ID = {
|
|||
|
|
fire: "י",
|
|||
|
|
water: "ה",
|
|||
|
|
air: "ו",
|
|||
|
|
earth: "ה"
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
const HEBREW_LETTER_ID_BY_TETRAGRAMMATON_LETTER = {
|
|||
|
|
yod: "yod",
|
|||
|
|
heh: "he",
|
|||
|
|
vav: "vav"
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
const ACE_ELEMENT_BY_CARD_NAME = {
|
|||
|
|
"ace of cups": "water",
|
|||
|
|
"ace of wands": "fire",
|
|||
|
|
"ace of swords": "air",
|
|||
|
|
"ace of disks": "earth"
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
const COURT_ELEMENT_BY_RANK = {
|
|||
|
|
knight: "fire",
|
|||
|
|
queen: "water",
|
|||
|
|
prince: "air",
|
|||
|
|
princess: "earth"
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
const SUIT_ELEMENT_BY_SUIT = {
|
|||
|
|
wands: "fire",
|
|||
|
|
cups: "water",
|
|||
|
|
swords: "air",
|
|||
|
|
disks: "earth"
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
const MINOR_RANK_NUMBER_BY_NAME = {
|
|||
|
|
ace: 1,
|
|||
|
|
two: 2,
|
|||
|
|
three: 3,
|
|||
|
|
four: 4,
|
|||
|
|
five: 5,
|
|||
|
|
six: 6,
|
|||
|
|
seven: 7,
|
|||
|
|
eight: 8,
|
|||
|
|
nine: 9,
|
|||
|
|
ten: 10
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
const SMALL_CARD_SIGN_BY_MODALITY_AND_SUIT = {
|
|||
|
|
cardinal: {
|
|||
|
|
wands: "aries",
|
|||
|
|
cups: "cancer",
|
|||
|
|
swords: "libra",
|
|||
|
|
disks: "capricorn"
|
|||
|
|
},
|
|||
|
|
fixed: {
|
|||
|
|
wands: "leo",
|
|||
|
|
cups: "scorpio",
|
|||
|
|
swords: "aquarius",
|
|||
|
|
disks: "taurus"
|
|||
|
|
},
|
|||
|
|
mutable: {
|
|||
|
|
wands: "sagittarius",
|
|||
|
|
cups: "pisces",
|
|||
|
|
swords: "gemini",
|
|||
|
|
disks: "virgo"
|
|||
|
|
}
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
function slugify(value) {
|
|||
|
|
return String(value || "")
|
|||
|
|
.trim()
|
|||
|
|
.toLowerCase()
|
|||
|
|
.replace(/[^a-z0-9]+/g, "-")
|
|||
|
|
.replace(/(^-|-$)/g, "");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function cardId(card) {
|
|||
|
|
const suitPart = card.suit ? `-${slugify(card.suit)}` : "";
|
|||
|
|
return `${slugify(card.arcana)}${suitPart}-${slugify(card.name)}`;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function getElements() {
|
|||
|
|
return {
|
|||
|
|
tarotCardListEl: document.getElementById("tarot-card-list"),
|
|||
|
|
tarotSearchInputEl: document.getElementById("tarot-search-input"),
|
|||
|
|
tarotSearchClearEl: document.getElementById("tarot-search-clear"),
|
|||
|
|
tarotCountEl: document.getElementById("tarot-card-count"),
|
|||
|
|
tarotDetailImageEl: document.getElementById("tarot-detail-image"),
|
|||
|
|
tarotDetailNameEl: document.getElementById("tarot-detail-name"),
|
|||
|
|
tarotDetailTypeEl: document.getElementById("tarot-detail-type"),
|
|||
|
|
tarotDetailSummaryEl: document.getElementById("tarot-detail-summary"),
|
|||
|
|
tarotDetailUprightEl: document.getElementById("tarot-detail-upright"),
|
|||
|
|
tarotDetailReversedEl: document.getElementById("tarot-detail-reversed"),
|
|||
|
|
tarotMetaMeaningCardEl: document.getElementById("tarot-meta-meaning-card"),
|
|||
|
|
tarotDetailMeaningEl: document.getElementById("tarot-detail-meaning"),
|
|||
|
|
tarotDetailKeywordsEl: document.getElementById("tarot-detail-keywords"),
|
|||
|
|
tarotMetaPlanetCardEl: document.getElementById("tarot-meta-planet-card"),
|
|||
|
|
tarotMetaElementCardEl: document.getElementById("tarot-meta-element-card"),
|
|||
|
|
tarotMetaTetragrammatonCardEl: document.getElementById("tarot-meta-tetragrammaton-card"),
|
|||
|
|
tarotMetaZodiacCardEl: document.getElementById("tarot-meta-zodiac-card"),
|
|||
|
|
tarotMetaCourtDateCardEl: document.getElementById("tarot-meta-courtdate-card"),
|
|||
|
|
tarotMetaHebrewCardEl: document.getElementById("tarot-meta-hebrew-card"),
|
|||
|
|
tarotMetaCubeCardEl: document.getElementById("tarot-meta-cube-card"),
|
|||
|
|
tarotMetaCalendarCardEl: document.getElementById("tarot-meta-calendar-card"),
|
|||
|
|
tarotDetailPlanetEl: document.getElementById("tarot-detail-planet"),
|
|||
|
|
tarotDetailElementEl: document.getElementById("tarot-detail-element"),
|
|||
|
|
tarotDetailTetragrammatonEl: document.getElementById("tarot-detail-tetragrammaton"),
|
|||
|
|
tarotDetailZodiacEl: document.getElementById("tarot-detail-zodiac"),
|
|||
|
|
tarotDetailCourtDateEl: document.getElementById("tarot-detail-courtdate"),
|
|||
|
|
tarotDetailHebrewEl: document.getElementById("tarot-detail-hebrew"),
|
|||
|
|
tarotDetailCubeEl: document.getElementById("tarot-detail-cube"),
|
|||
|
|
tarotDetailCalendarEl: document.getElementById("tarot-detail-calendar"),
|
|||
|
|
tarotKabPathEl: document.getElementById("tarot-kab-path"),
|
|||
|
|
tarotHouseOfCardsEl: document.getElementById("tarot-house-of-cards")
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function normalizeRelationId(value) {
|
|||
|
|
return String(value || "")
|
|||
|
|
.trim()
|
|||
|
|
.toLowerCase()
|
|||
|
|
.replace(/[^a-z0-9]+/g, "-")
|
|||
|
|
.replace(/(^-|-$)/g, "");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function normalizeSearchValue(value) {
|
|||
|
|
return String(value || "").trim().toLowerCase();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function normalizeTarotName(value) {
|
|||
|
|
return String(value || "")
|
|||
|
|
.trim()
|
|||
|
|
.toLowerCase()
|
|||
|
|
.replace(/\s+/g, " ");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function normalizeTarotCardLookupName(value) {
|
|||
|
|
const text = normalizeTarotName(value)
|
|||
|
|
.replace(/\b(pentacles?|coins?)\b/g, "disks");
|
|||
|
|
|
|||
|
|
const match = text.match(/^(\d{1,2})\s+of\s+(.+)$/i);
|
|||
|
|
if (!match) {
|
|||
|
|
return text;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const numeric = Number(match[1]);
|
|||
|
|
const suit = String(match[2] || "").trim();
|
|||
|
|
const rankWord = MINOR_NUMBER_WORD_BY_VALUE[numeric];
|
|||
|
|
if (!rankWord || !suit) {
|
|||
|
|
return text;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return `${rankWord} of ${suit}`;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function getDisplayCardName(cardOrName, trumpNumber) {
|
|||
|
|
const cardName = typeof cardOrName === "object"
|
|||
|
|
? String(cardOrName?.name || "")
|
|||
|
|
: String(cardOrName || "");
|
|||
|
|
|
|||
|
|
const resolvedTrumpNumber = typeof cardOrName === "object"
|
|||
|
|
? cardOrName?.number
|
|||
|
|
: trumpNumber;
|
|||
|
|
|
|||
|
|
if (typeof getTarotCardDisplayName === "function") {
|
|||
|
|
const display = String(getTarotCardDisplayName(cardName, { trumpNumber: resolvedTrumpNumber }) || "").trim();
|
|||
|
|
if (display) {
|
|||
|
|
return display;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return cardName.trim();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function toTitleCase(value) {
|
|||
|
|
return String(value || "")
|
|||
|
|
.split(" ")
|
|||
|
|
.filter(Boolean)
|
|||
|
|
.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
|
|||
|
|
.join(" ");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function resolveElementIdForCard(card) {
|
|||
|
|
if (!card) {
|
|||
|
|
return "";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const cardLookupName = normalizeTarotCardLookupName(card.name);
|
|||
|
|
const rankKey = String(card.rank || "").trim().toLowerCase();
|
|||
|
|
|
|||
|
|
return ACE_ELEMENT_BY_CARD_NAME[cardLookupName] || COURT_ELEMENT_BY_RANK[rankKey] || "";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function createElementRelation(card, elementId, sourceKind, sourceLabel) {
|
|||
|
|
if (!card || !elementId) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const elementName = ELEMENT_NAME_BY_ID[elementId] || toTitleCase(elementId);
|
|||
|
|
const hebrewLetter = ELEMENT_HEBREW_LETTER_BY_ID[elementId] || "";
|
|||
|
|
const hebrewChar = ELEMENT_HEBREW_CHAR_BY_ID[elementId] || "";
|
|||
|
|
const relationLabel = `${elementName}${hebrewChar ? ` (${hebrewChar})` : (hebrewLetter ? ` (${hebrewLetter})` : "")} · ${sourceLabel}`;
|
|||
|
|
|
|||
|
|
return {
|
|||
|
|
type: "element",
|
|||
|
|
id: elementId,
|
|||
|
|
label: relationLabel,
|
|||
|
|
data: {
|
|||
|
|
elementId,
|
|||
|
|
name: elementName,
|
|||
|
|
tarotCard: card.name,
|
|||
|
|
hebrewLetter,
|
|||
|
|
hebrewChar,
|
|||
|
|
sourceKind,
|
|||
|
|
sourceLabel,
|
|||
|
|
rank: card.rank || "",
|
|||
|
|
suit: card.suit || ""
|
|||
|
|
},
|
|||
|
|
__key: `element|${elementId}|${sourceKind}|${normalizeRelationId(sourceLabel)}|${card.id || normalizeTarotCardLookupName(card.name)}`
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function buildElementRelationsForCard(card, baseElementRelations = []) {
|
|||
|
|
if (!card) {
|
|||
|
|
return [];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (card.arcana === "Major") {
|
|||
|
|
return Array.isArray(baseElementRelations) ? [...baseElementRelations] : [];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const relations = [];
|
|||
|
|
|
|||
|
|
const suitKey = String(card.suit || "").trim().toLowerCase();
|
|||
|
|
const suitElementId = SUIT_ELEMENT_BY_SUIT[suitKey] || "";
|
|||
|
|
if (suitElementId) {
|
|||
|
|
const suitRelation = createElementRelation(card, suitElementId, "suit", `Suit: ${card.suit}`);
|
|||
|
|
if (suitRelation) {
|
|||
|
|
relations.push(suitRelation);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const rankKey = String(card.rank || "").trim().toLowerCase();
|
|||
|
|
const courtElementId = COURT_ELEMENT_BY_RANK[rankKey] || "";
|
|||
|
|
if (courtElementId) {
|
|||
|
|
const courtRelation = createElementRelation(card, courtElementId, "court", `Court: ${card.rank}`);
|
|||
|
|
if (courtRelation) {
|
|||
|
|
relations.push(courtRelation);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return relations;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function buildTetragrammatonRelationsForCard(card) {
|
|||
|
|
if (!card) {
|
|||
|
|
return [];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const elementId = resolveElementIdForCard(card);
|
|||
|
|
if (!elementId) {
|
|||
|
|
return [];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const letter = ELEMENT_HEBREW_LETTER_BY_ID[elementId] || "";
|
|||
|
|
if (!letter) {
|
|||
|
|
return [];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const elementName = ELEMENT_NAME_BY_ID[elementId] || elementId;
|
|||
|
|
const letterKey = String(letter || "").trim().toLowerCase();
|
|||
|
|
const hebrewLetterId = HEBREW_LETTER_ID_BY_TETRAGRAMMATON_LETTER[letterKey] || "";
|
|||
|
|
|
|||
|
|
return [{
|
|||
|
|
type: "tetragrammaton",
|
|||
|
|
id: `${letterKey}-${elementId}`,
|
|||
|
|
label: `${letter} · ${elementName}`,
|
|||
|
|
data: {
|
|||
|
|
letter,
|
|||
|
|
elementId,
|
|||
|
|
elementName,
|
|||
|
|
hebrewLetterId
|
|||
|
|
},
|
|||
|
|
__key: `tetragrammaton|${letterKey}|${elementId}|${card.id || normalizeTarotCardLookupName(card.name)}`
|
|||
|
|
}];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function getSmallCardModality(rankNumber) {
|
|||
|
|
const numeric = Number(rankNumber);
|
|||
|
|
if (!Number.isFinite(numeric) || numeric < 2 || numeric > 10) {
|
|||
|
|
return "";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (numeric <= 4) {
|
|||
|
|
return "cardinal";
|
|||
|
|
}
|
|||
|
|
if (numeric <= 7) {
|
|||
|
|
return "fixed";
|
|||
|
|
}
|
|||
|
|
return "mutable";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function buildSmallCardRulershipRelation(card) {
|
|||
|
|
if (!card || card.arcana !== "Minor") {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const rankKey = String(card.rank || "").trim().toLowerCase();
|
|||
|
|
const rankNumber = MINOR_RANK_NUMBER_BY_NAME[rankKey];
|
|||
|
|
const modality = getSmallCardModality(rankNumber);
|
|||
|
|
if (!modality) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const suitKey = String(card.suit || "").trim().toLowerCase();
|
|||
|
|
const signId = SMALL_CARD_SIGN_BY_MODALITY_AND_SUIT[modality]?.[suitKey] || "";
|
|||
|
|
if (!signId) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const sign = (Array.isArray(state.referenceData?.signs) ? state.referenceData.signs : [])
|
|||
|
|
.find((entry) => String(entry?.id || "").trim().toLowerCase() === signId);
|
|||
|
|
|
|||
|
|
const signName = String(sign?.name || toTitleCase(signId));
|
|||
|
|
const signSymbol = String(sign?.symbol || "").trim();
|
|||
|
|
const modalityName = toTitleCase(modality);
|
|||
|
|
|
|||
|
|
return {
|
|||
|
|
type: "zodiacRulership",
|
|||
|
|
id: `${signId}-${rankKey}-${suitKey}`,
|
|||
|
|
label: `Sign type: ${modalityName} · ${signSymbol} ${signName}`.trim(),
|
|||
|
|
data: {
|
|||
|
|
signId,
|
|||
|
|
signName,
|
|||
|
|
symbol: signSymbol,
|
|||
|
|
modality,
|
|||
|
|
rank: card.rank,
|
|||
|
|
suit: card.suit
|
|||
|
|
},
|
|||
|
|
__key: `zodiacRulership|${signId}|${rankKey}|${suitKey}`
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function buildCourtCardByDecanId(cards) {
|
|||
|
|
const map = new Map();
|
|||
|
|
|
|||
|
|
(cards || []).forEach((card) => {
|
|||
|
|
if (!card || card.arcana !== "Minor") {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const rankKey = String(card.rank || "").trim().toLowerCase();
|
|||
|
|
if (rankKey !== "knight" && rankKey !== "queen" && rankKey !== "prince") {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const windowRelation = (Array.isArray(card.relations) ? card.relations : [])
|
|||
|
|
.find((relation) => relation && typeof relation === "object" && relation.type === "courtDateWindow");
|
|||
|
|
|
|||
|
|
const decanIds = Array.isArray(windowRelation?.data?.decanIds)
|
|||
|
|
? windowRelation.data.decanIds
|
|||
|
|
: [];
|
|||
|
|
|
|||
|
|
decanIds.forEach((decanId) => {
|
|||
|
|
const decanKey = normalizeRelationId(decanId);
|
|||
|
|
if (!decanKey || map.has(decanKey)) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
map.set(decanKey, {
|
|||
|
|
cardName: card.name,
|
|||
|
|
rank: card.rank,
|
|||
|
|
suit: card.suit,
|
|||
|
|
dateRange: String(windowRelation?.data?.dateRange || "").trim()
|
|||
|
|
});
|
|||
|
|
});
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
return map;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function buildSmallCardCourtLinkRelations(card, relations) {
|
|||
|
|
if (!card || card.arcana !== "Minor") {
|
|||
|
|
return [];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const rankKey = String(card.rank || "").trim().toLowerCase();
|
|||
|
|
const rankNumber = MINOR_RANK_NUMBER_BY_NAME[rankKey];
|
|||
|
|
if (!Number.isFinite(rankNumber) || rankNumber < 2 || rankNumber > 10) {
|
|||
|
|
return [];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const decans = (relations || []).filter((relation) => relation?.type === "decan");
|
|||
|
|
if (!decans.length) {
|
|||
|
|
return [];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const results = [];
|
|||
|
|
const seenCourtCardNames = new Set();
|
|||
|
|
|
|||
|
|
decans.forEach((decan) => {
|
|||
|
|
const signId = String(decan?.data?.signId || "").trim().toLowerCase();
|
|||
|
|
const decanIndex = Number(decan?.data?.index);
|
|||
|
|
if (!signId || !Number.isFinite(decanIndex)) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const decanId = normalizeRelationId(`${signId}-${decanIndex}`);
|
|||
|
|
const linkedCourt = state.courtCardByDecanId.get(decanId);
|
|||
|
|
if (!linkedCourt?.cardName || seenCourtCardNames.has(linkedCourt.cardName)) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
seenCourtCardNames.add(linkedCourt.cardName);
|
|||
|
|
|
|||
|
|
results.push({
|
|||
|
|
type: "tarotCard",
|
|||
|
|
id: `${decanId}-${normalizeRelationId(linkedCourt.cardName)}`,
|
|||
|
|
label: `Shared court date window: ${linkedCourt.cardName}${linkedCourt.dateRange ? ` · ${linkedCourt.dateRange}` : ""}`,
|
|||
|
|
data: {
|
|||
|
|
cardName: linkedCourt.cardName,
|
|||
|
|
dateRange: linkedCourt.dateRange || "",
|
|||
|
|
decanId
|
|||
|
|
},
|
|||
|
|
__key: `tarotCard|${decanId}|${normalizeRelationId(linkedCourt.cardName)}`
|
|||
|
|
});
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
return results;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function normalizeHebrewLetterId(value) {
|
|||
|
|
const key = String(value || "")
|
|||
|
|
.trim()
|
|||
|
|
.toLowerCase()
|
|||
|
|
.replace(/[^a-z]/g, "");
|
|||
|
|
return HEBREW_LETTER_ALIASES[key] || key;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
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 cardMatchesTarotAssociation(card, tarotCardName) {
|
|||
|
|
const associationName = normalizeTarotName(tarotCardName);
|
|||
|
|
if (!associationName || !card) {
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const cardName = normalizeTarotName(card.name);
|
|||
|
|
const cardBare = cardName.replace(/^the\s+/, "");
|
|||
|
|
const assocBare = associationName.replace(/^the\s+/, "");
|
|||
|
|
|
|||
|
|
if (
|
|||
|
|
associationName === cardName ||
|
|||
|
|
associationName === cardBare ||
|
|||
|
|
assocBare === cardName ||
|
|||
|
|
assocBare === cardBare
|
|||
|
|
) {
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (card.arcana === "Major" && Number.isFinite(Number(card.number))) {
|
|||
|
|
const trumpNumber = resolveTarotTrumpNumber(associationName);
|
|||
|
|
if (trumpNumber != null) {
|
|||
|
|
return trumpNumber === Number(card.number);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function parseMonthDayToken(value) {
|
|||
|
|
const text = String(value || "").trim();
|
|||
|
|
const match = text.match(/^(\d{1,2})-(\d{1,2})$/);
|
|||
|
|
if (!match) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const month = Number(match[1]);
|
|||
|
|
const day = Number(match[2]);
|
|||
|
|
if (!Number.isInteger(month) || !Number.isInteger(day) || month < 1 || month > 12 || day < 1 || day > 31) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return { month, day };
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function toReferenceDate(token, year) {
|
|||
|
|
if (!token) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
return new Date(year, token.month - 1, token.day, 12, 0, 0, 0);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function splitMonthDayRangeByMonth(startToken, endToken) {
|
|||
|
|
const startDate = toReferenceDate(startToken, 2025);
|
|||
|
|
const endBase = toReferenceDate(endToken, 2025);
|
|||
|
|
if (!startDate || !endBase) {
|
|||
|
|
return [];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const wrapsYear = endBase.getTime() < startDate.getTime();
|
|||
|
|
const endDate = wrapsYear ? toReferenceDate(endToken, 2026) : endBase;
|
|||
|
|
if (!endDate) {
|
|||
|
|
return [];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const segments = [];
|
|||
|
|
let cursor = new Date(startDate);
|
|||
|
|
|
|||
|
|
while (cursor.getTime() <= endDate.getTime()) {
|
|||
|
|
const monthEnd = new Date(cursor.getFullYear(), cursor.getMonth() + 1, 0, 12, 0, 0, 0);
|
|||
|
|
const segmentEnd = monthEnd.getTime() < endDate.getTime() ? monthEnd : endDate;
|
|||
|
|
|
|||
|
|
segments.push({
|
|||
|
|
monthNo: cursor.getMonth() + 1,
|
|||
|
|
startDay: cursor.getDate(),
|
|||
|
|
endDay: segmentEnd.getDate()
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
cursor = new Date(segmentEnd.getFullYear(), segmentEnd.getMonth(), segmentEnd.getDate() + 1, 12, 0, 0, 0);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return segments;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function formatMonthDayRangeLabel(monthName, startDay, endDay) {
|
|||
|
|
const start = Number(startDay);
|
|||
|
|
const end = Number(endDay);
|
|||
|
|
if (!Number.isFinite(start) || !Number.isFinite(end)) {
|
|||
|
|
return monthName;
|
|||
|
|
}
|
|||
|
|
if (start === end) {
|
|||
|
|
return `${monthName} ${start}`;
|
|||
|
|
}
|
|||
|
|
return `${monthName} ${start}-${end}`;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function buildMonthReferencesByCard(referenceData, cards) {
|
|||
|
|
const map = new Map();
|
|||
|
|
const months = Array.isArray(referenceData?.calendarMonths) ? referenceData.calendarMonths : [];
|
|||
|
|
const holidays = Array.isArray(referenceData?.celestialHolidays) ? referenceData.celestialHolidays : [];
|
|||
|
|
const signs = Array.isArray(referenceData?.signs) ? referenceData.signs : [];
|
|||
|
|
const monthById = new Map(months.map((month) => [month.id, month]));
|
|||
|
|
|
|||
|
|
function parseMonthFromDateToken(value) {
|
|||
|
|
const token = parseMonthDayToken(value);
|
|||
|
|
return token ? token.month : null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function findMonthByNumber(monthNo) {
|
|||
|
|
if (!Number.isInteger(monthNo) || monthNo < 1 || monthNo > 12) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const byOrder = months.find((month) => Number(month?.order) === monthNo);
|
|||
|
|
if (byOrder) {
|
|||
|
|
return byOrder;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return months.find((month) => parseMonthFromDateToken(month?.start) === monthNo) || null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function pushRef(card, month, options = {}) {
|
|||
|
|
if (!card?.id || !month?.id) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (!map.has(card.id)) {
|
|||
|
|
map.set(card.id, []);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const rows = map.get(card.id);
|
|||
|
|
const monthOrder = Number.isFinite(Number(month.order)) ? Number(month.order) : 999;
|
|||
|
|
const startToken = parseMonthDayToken(options.startToken || month.start);
|
|||
|
|
const endToken = parseMonthDayToken(options.endToken || month.end);
|
|||
|
|
const dateRange = String(options.dateRange || "").trim() || (
|
|||
|
|
startToken && endToken
|
|||
|
|
? formatMonthDayRangeLabel(month.name || month.id, startToken.day, endToken.day)
|
|||
|
|
: ""
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
const uniqueKey = [
|
|||
|
|
month.id,
|
|||
|
|
dateRange.toLowerCase(),
|
|||
|
|
String(options.context || "").trim().toLowerCase(),
|
|||
|
|
String(options.source || "").trim().toLowerCase()
|
|||
|
|
].join("|");
|
|||
|
|
|
|||
|
|
if (rows.some((entry) => entry.uniqueKey === uniqueKey)) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
rows.push({
|
|||
|
|
id: month.id,
|
|||
|
|
name: month.name || month.id,
|
|||
|
|
order: monthOrder,
|
|||
|
|
startToken: startToken ? `${String(startToken.month).padStart(2, "0")}-${String(startToken.day).padStart(2, "0")}` : null,
|
|||
|
|
endToken: endToken ? `${String(endToken.month).padStart(2, "0")}-${String(endToken.day).padStart(2, "0")}` : null,
|
|||
|
|
dateRange,
|
|||
|
|
context: String(options.context || "").trim(),
|
|||
|
|
source: String(options.source || "").trim(),
|
|||
|
|
uniqueKey
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function captureRefs(associations, month) {
|
|||
|
|
const tarotCardName = associations?.tarotCard;
|
|||
|
|
if (!tarotCardName) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
cards.forEach((card) => {
|
|||
|
|
if (cardMatchesTarotAssociation(card, tarotCardName)) {
|
|||
|
|
pushRef(card, month);
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
months.forEach((month) => {
|
|||
|
|
captureRefs(month?.associations, month);
|
|||
|
|
|
|||
|
|
const events = Array.isArray(month?.events) ? month.events : [];
|
|||
|
|
events.forEach((event) => {
|
|||
|
|
const tarotCardName = event?.associations?.tarotCard;
|
|||
|
|
if (!tarotCardName) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
cards.forEach((card) => {
|
|||
|
|
if (!cardMatchesTarotAssociation(card, tarotCardName)) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
pushRef(card, month, {
|
|||
|
|
source: "month-event",
|
|||
|
|
context: String(event?.name || "").trim()
|
|||
|
|
});
|
|||
|
|
});
|
|||
|
|
});
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
holidays.forEach((holiday) => {
|
|||
|
|
const month = monthById.get(holiday?.monthId);
|
|||
|
|
if (!month) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
const tarotCardName = holiday?.associations?.tarotCard;
|
|||
|
|
if (!tarotCardName) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
cards.forEach((card) => {
|
|||
|
|
if (!cardMatchesTarotAssociation(card, tarotCardName)) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
pushRef(card, month, {
|
|||
|
|
source: "holiday",
|
|||
|
|
context: String(holiday?.name || "").trim()
|
|||
|
|
});
|
|||
|
|
});
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
signs.forEach((sign) => {
|
|||
|
|
const signTrumpNumber = Number(sign?.tarot?.number);
|
|||
|
|
const signTarotName = sign?.tarot?.majorArcana || sign?.tarot?.card || sign?.tarotCard;
|
|||
|
|
if (!Number.isFinite(signTrumpNumber) && !signTarotName) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const signName = String(sign?.name || sign?.id || "").trim();
|
|||
|
|
const startToken = parseMonthDayToken(sign?.start);
|
|||
|
|
const endToken = parseMonthDayToken(sign?.end);
|
|||
|
|
const monthSegments = splitMonthDayRangeByMonth(startToken, endToken);
|
|||
|
|
const fallbackStartMonthNo = parseMonthFromDateToken(sign?.start);
|
|||
|
|
const fallbackEndMonthNo = parseMonthFromDateToken(sign?.end);
|
|||
|
|
const fallbackStartMonth = findMonthByNumber(fallbackStartMonthNo);
|
|||
|
|
const fallbackEndMonth = findMonthByNumber(fallbackEndMonthNo);
|
|||
|
|
|
|||
|
|
cards.forEach((card) => {
|
|||
|
|
const cardTrumpNumber = Number(card?.number);
|
|||
|
|
const matchesByTrump = card?.arcana === "Major"
|
|||
|
|
&& Number.isFinite(cardTrumpNumber)
|
|||
|
|
&& Number.isFinite(signTrumpNumber)
|
|||
|
|
&& cardTrumpNumber === signTrumpNumber;
|
|||
|
|
const matchesByName = signTarotName ? cardMatchesTarotAssociation(card, signTarotName) : false;
|
|||
|
|
|
|||
|
|
if (!matchesByTrump && !matchesByName) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (monthSegments.length) {
|
|||
|
|
monthSegments.forEach((segment) => {
|
|||
|
|
const month = findMonthByNumber(segment.monthNo);
|
|||
|
|
if (!month) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
pushRef(card, month, {
|
|||
|
|
source: "zodiac-window",
|
|||
|
|
context: signName ? `${signName} window` : "",
|
|||
|
|
startToken: `${String(segment.monthNo).padStart(2, "0")}-${String(segment.startDay).padStart(2, "0")}`,
|
|||
|
|
endToken: `${String(segment.monthNo).padStart(2, "0")}-${String(segment.endDay).padStart(2, "0")}`,
|
|||
|
|
dateRange: formatMonthDayRangeLabel(month.name || month.id, segment.startDay, segment.endDay)
|
|||
|
|
});
|
|||
|
|
});
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (fallbackStartMonth) {
|
|||
|
|
pushRef(card, fallbackStartMonth, {
|
|||
|
|
source: "zodiac-window",
|
|||
|
|
context: signName ? `${signName} window` : ""
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
if (fallbackEndMonth && (!fallbackStartMonth || fallbackEndMonth.id !== fallbackStartMonth.id)) {
|
|||
|
|
pushRef(card, fallbackEndMonth, {
|
|||
|
|
source: "zodiac-window",
|
|||
|
|
context: signName ? `${signName} window` : ""
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
map.forEach((rows, key) => {
|
|||
|
|
const monthIdsWithZodiacWindows = new Set(
|
|||
|
|
rows
|
|||
|
|
.filter((entry) => entry?.source === "zodiac-window" && entry?.id)
|
|||
|
|
.map((entry) => entry.id)
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
const filteredRows = rows.filter((entry) => {
|
|||
|
|
if (!entry?.id || entry?.source === "zodiac-window") {
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (!monthIdsWithZodiacWindows.has(entry.id)) {
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const month = monthById.get(entry.id);
|
|||
|
|
if (!month) {
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const isFullMonth = String(entry.startToken || "") === String(month.start || "")
|
|||
|
|
&& String(entry.endToken || "") === String(month.end || "");
|
|||
|
|
|
|||
|
|
return !isFullMonth;
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
filteredRows.sort((left, right) => {
|
|||
|
|
if (left.order !== right.order) {
|
|||
|
|
return left.order - right.order;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const startLeft = parseMonthDayToken(left.startToken);
|
|||
|
|
const startRight = parseMonthDayToken(right.startToken);
|
|||
|
|
const dayLeft = startLeft ? startLeft.day : 999;
|
|||
|
|
const dayRight = startRight ? startRight.day : 999;
|
|||
|
|
if (dayLeft !== dayRight) {
|
|||
|
|
return dayLeft - dayRight;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return String(left.dateRange || left.name || "").localeCompare(String(right.dateRange || right.name || ""));
|
|||
|
|
});
|
|||
|
|
map.set(key, filteredRows);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
return map;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function relationToSearchText(relation) {
|
|||
|
|
if (!relation) {
|
|||
|
|
return "";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (typeof relation === "string") {
|
|||
|
|
return relation;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const relationParts = [
|
|||
|
|
relation.label,
|
|||
|
|
relation.type,
|
|||
|
|
relation.id,
|
|||
|
|
relation.data && typeof relation.data === "object"
|
|||
|
|
? Object.values(relation.data).join(" ")
|
|||
|
|
: ""
|
|||
|
|
];
|
|||
|
|
|
|||
|
|
return relationParts.filter(Boolean).join(" ");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function buildCardSearchText(card) {
|
|||
|
|
const displayName = getDisplayCardName(card);
|
|||
|
|
const tarotAliases = typeof getTarotCardSearchAliases === "function"
|
|||
|
|
? getTarotCardSearchAliases(card?.name, { trumpNumber: card?.number })
|
|||
|
|
: [];
|
|||
|
|
const parts = [
|
|||
|
|
card.name,
|
|||
|
|
displayName,
|
|||
|
|
card.arcana,
|
|||
|
|
card.rank,
|
|||
|
|
card.suit,
|
|||
|
|
card.summary,
|
|||
|
|
...tarotAliases,
|
|||
|
|
...(Array.isArray(card.keywords) ? card.keywords : []),
|
|||
|
|
...(Array.isArray(card.relations) ? card.relations.map(relationToSearchText) : [])
|
|||
|
|
];
|
|||
|
|
|
|||
|
|
return normalizeSearchValue(parts.join(" "));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function applySearchFilter(elements) {
|
|||
|
|
const query = normalizeSearchValue(state.searchQuery);
|
|||
|
|
state.filteredCards = query
|
|||
|
|
? state.cards.filter((card) => buildCardSearchText(card).includes(query))
|
|||
|
|
: [...state.cards];
|
|||
|
|
|
|||
|
|
if (elements?.tarotSearchClearEl) {
|
|||
|
|
elements.tarotSearchClearEl.disabled = !query;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
renderList(elements);
|
|||
|
|
|
|||
|
|
if (!state.filteredCards.some((card) => card.id === state.selectedCardId)) {
|
|||
|
|
if (state.filteredCards.length > 0) {
|
|||
|
|
selectCardById(state.filteredCards[0].id, elements);
|
|||
|
|
}
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
updateListSelection(elements);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function clearChildren(element) {
|
|||
|
|
if (element) {
|
|||
|
|
element.replaceChildren();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function getCardLookupMap(cards) {
|
|||
|
|
const map = new Map();
|
|||
|
|
(cards || []).forEach((card) => {
|
|||
|
|
const key = normalizeTarotCardLookupName(card?.name);
|
|||
|
|
if (key) {
|
|||
|
|
map.set(key, card);
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
return map;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function buildMinorCardName(rankNumber, suit) {
|
|||
|
|
const rank = MINOR_TITLE_WORD_BY_VALUE[Number(rankNumber)];
|
|||
|
|
const suitName = String(suit || "").trim();
|
|||
|
|
if (!rank || !suitName) {
|
|||
|
|
return "";
|
|||
|
|
}
|
|||
|
|
return `${rank} of ${suitName}`;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function buildCourtCardName(rank, suit) {
|
|||
|
|
const rankName = String(rank || "").trim();
|
|||
|
|
const suitName = String(suit || "").trim();
|
|||
|
|
if (!rankName || !suitName) {
|
|||
|
|
return "";
|
|||
|
|
}
|
|||
|
|
return `${rankName} of ${suitName}`;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function findCardByLookupName(cardLookupMap, cardName) {
|
|||
|
|
const key = normalizeTarotCardLookupName(cardName);
|
|||
|
|
if (!key) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
return cardLookupMap.get(key) || null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function findMajorCardByTrumpNumber(cards, trumpNumber) {
|
|||
|
|
const target = Number(trumpNumber);
|
|||
|
|
if (!Number.isFinite(target)) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
return (cards || []).find((card) => card?.arcana === "Major" && Number(card?.number) === target) || null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function createHouseCardButton(card, elements) {
|
|||
|
|
const button = document.createElement("button");
|
|||
|
|
button.type = "button";
|
|||
|
|
button.className = "tarot-house-card-btn";
|
|||
|
|
|
|||
|
|
if (!card) {
|
|||
|
|
button.disabled = true;
|
|||
|
|
const fallback = document.createElement("span");
|
|||
|
|
fallback.className = "tarot-house-card-fallback";
|
|||
|
|
fallback.textContent = "Missing";
|
|||
|
|
button.appendChild(fallback);
|
|||
|
|
return button;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const cardDisplayName = getDisplayCardName(card);
|
|||
|
|
button.title = cardDisplayName || card.name;
|
|||
|
|
button.setAttribute("aria-label", cardDisplayName || card.name);
|
|||
|
|
button.dataset.houseCardId = card.id;
|
|||
|
|
const imageUrl = typeof resolveTarotCardImage === "function"
|
|||
|
|
? resolveTarotCardImage(card.name)
|
|||
|
|
: null;
|
|||
|
|
|
|||
|
|
if (imageUrl) {
|
|||
|
|
const image = document.createElement("img");
|
|||
|
|
image.className = "tarot-house-card-image";
|
|||
|
|
image.src = imageUrl;
|
|||
|
|
image.alt = cardDisplayName || card.name;
|
|||
|
|
button.appendChild(image);
|
|||
|
|
} else {
|
|||
|
|
const fallback = document.createElement("span");
|
|||
|
|
fallback.className = "tarot-house-card-fallback";
|
|||
|
|
fallback.textContent = cardDisplayName || card.name;
|
|||
|
|
button.appendChild(fallback);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
button.addEventListener("click", () => {
|
|||
|
|
selectCardById(card.id, elements);
|
|||
|
|
elements?.tarotCardListEl
|
|||
|
|
?.querySelector(`[data-card-id="${card.id}"]`)
|
|||
|
|
?.scrollIntoView({ block: "nearest" });
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
return button;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function updateHouseSelection(elements) {
|
|||
|
|
if (!elements?.tarotHouseOfCardsEl) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const buttons = elements.tarotHouseOfCardsEl.querySelectorAll(".tarot-house-card-btn[data-house-card-id]");
|
|||
|
|
buttons.forEach((button) => {
|
|||
|
|
const isSelected = button.dataset.houseCardId === state.selectedCardId;
|
|||
|
|
button.classList.toggle("is-selected", isSelected);
|
|||
|
|
button.setAttribute("aria-current", isSelected ? "true" : "false");
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function appendHouseMinorRow(columnEl, cardLookupMap, numbers, suit, elements) {
|
|||
|
|
const rowEl = document.createElement("div");
|
|||
|
|
rowEl.className = "tarot-house-row";
|
|||
|
|
|
|||
|
|
numbers.forEach((rankNumber) => {
|
|||
|
|
const cardName = buildMinorCardName(rankNumber, suit);
|
|||
|
|
const card = findCardByLookupName(cardLookupMap, cardName);
|
|||
|
|
rowEl.appendChild(createHouseCardButton(card, elements));
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
columnEl.appendChild(rowEl);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function appendHouseCourtRow(columnEl, cardLookupMap, rank, elements) {
|
|||
|
|
const rowEl = document.createElement("div");
|
|||
|
|
rowEl.className = "tarot-house-row";
|
|||
|
|
|
|||
|
|
HOUSE_MIDDLE_SUITS.forEach((suit) => {
|
|||
|
|
const cardName = buildCourtCardName(rank, suit);
|
|||
|
|
const card = findCardByLookupName(cardLookupMap, cardName);
|
|||
|
|
rowEl.appendChild(createHouseCardButton(card, elements));
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
columnEl.appendChild(rowEl);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function appendHouseTrumpRow(containerEl, trumpNumbers, elements) {
|
|||
|
|
const rowEl = document.createElement("div");
|
|||
|
|
rowEl.className = "tarot-house-trump-row";
|
|||
|
|
|
|||
|
|
(trumpNumbers || []).forEach((trumpNumber) => {
|
|||
|
|
const card = findMajorCardByTrumpNumber(state.cards, trumpNumber);
|
|||
|
|
rowEl.appendChild(createHouseCardButton(card, elements));
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
containerEl.appendChild(rowEl);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function renderHouseOfCards(elements) {
|
|||
|
|
if (!elements?.tarotHouseOfCardsEl) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
clearChildren(elements.tarotHouseOfCardsEl);
|
|||
|
|
const cardLookupMap = getCardLookupMap(state.cards);
|
|||
|
|
|
|||
|
|
const trumpSectionEl = document.createElement("div");
|
|||
|
|
trumpSectionEl.className = "tarot-house-trumps";
|
|||
|
|
HOUSE_TRUMP_ROWS.forEach((trumpRow) => {
|
|||
|
|
appendHouseTrumpRow(trumpSectionEl, trumpRow, elements);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
const bottomGridEl = document.createElement("div");
|
|||
|
|
bottomGridEl.className = "tarot-house-bottom-grid";
|
|||
|
|
|
|||
|
|
const leftColumnEl = document.createElement("div");
|
|||
|
|
leftColumnEl.className = "tarot-house-column";
|
|||
|
|
HOUSE_MINOR_NUMBER_BANDS.forEach((numbers, rowIndex) => {
|
|||
|
|
appendHouseMinorRow(leftColumnEl, cardLookupMap, numbers, HOUSE_LEFT_SUITS[rowIndex], elements);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
const middleColumnEl = document.createElement("div");
|
|||
|
|
middleColumnEl.className = "tarot-house-column";
|
|||
|
|
HOUSE_MIDDLE_RANKS.forEach((rank) => {
|
|||
|
|
appendHouseCourtRow(middleColumnEl, cardLookupMap, rank, elements);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
const rightColumnEl = document.createElement("div");
|
|||
|
|
rightColumnEl.className = "tarot-house-column";
|
|||
|
|
HOUSE_MINOR_NUMBER_BANDS.forEach((numbers, rowIndex) => {
|
|||
|
|
appendHouseMinorRow(rightColumnEl, cardLookupMap, numbers, HOUSE_RIGHT_SUITS[rowIndex], elements);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
bottomGridEl.append(leftColumnEl, middleColumnEl, rightColumnEl);
|
|||
|
|
elements.tarotHouseOfCardsEl.append(trumpSectionEl, bottomGridEl);
|
|||
|
|
updateHouseSelection(elements);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function buildTypeLabel(card) {
|
|||
|
|
if (card.arcana === "Major") {
|
|||
|
|
return typeof card.number === "number"
|
|||
|
|
? `Major Arcana · ${card.number}`
|
|||
|
|
: "Major Arcana";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const parts = ["Minor Arcana"];
|
|||
|
|
if (card.rank) {
|
|||
|
|
parts.push(card.rank);
|
|||
|
|
}
|
|||
|
|
if (card.suit) {
|
|||
|
|
parts.push(card.suit);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return parts.join(" · ");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const MINOR_PLURAL_BY_RANK = {
|
|||
|
|
ace: "aces",
|
|||
|
|
two: "twos",
|
|||
|
|
three: "threes",
|
|||
|
|
four: "fours",
|
|||
|
|
five: "fives",
|
|||
|
|
six: "sixes",
|
|||
|
|
seven: "sevens",
|
|||
|
|
eight: "eights",
|
|||
|
|
nine: "nines",
|
|||
|
|
ten: "tens"
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
function findSephirahForMinorCard(card, kabTree) {
|
|||
|
|
if (!card || card.arcana !== "Minor" || !kabTree) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const rankKey = String(card.rank || "").trim().toLowerCase();
|
|||
|
|
const plural = MINOR_PLURAL_BY_RANK[rankKey];
|
|||
|
|
if (!plural) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const matcher = new RegExp(`\\b4\\s+${plural}\\b`, "i");
|
|||
|
|
return (kabTree.sephiroth || []).find((seph) => matcher.test(String(seph?.tarot || ""))) || null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function formatRelation(relation) {
|
|||
|
|
if (typeof relation === "string") {
|
|||
|
|
return relation;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (!relation || typeof relation !== "object") {
|
|||
|
|
return "";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (typeof relation.label === "string" && relation.label.trim()) {
|
|||
|
|
return relation.label;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (relation.type === "hebrewLetter" && relation.data) {
|
|||
|
|
const glyph = relation.data.glyph || "";
|
|||
|
|
const name = relation.data.name || relation.id || "Unknown";
|
|||
|
|
const latin = relation.data.latin ? ` (${relation.data.latin})` : "";
|
|||
|
|
const index = Number.isFinite(relation.data.index) ? relation.data.index : "?";
|
|||
|
|
const value = Number.isFinite(relation.data.value) ? relation.data.value : "?";
|
|||
|
|
const meaning = relation.data.meaning ? ` · ${relation.data.meaning}` : "";
|
|||
|
|
return `Hebrew Letter: ${glyph} ${name}${latin} (index ${index}, value ${value})${meaning}`.trim();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (typeof relation.type === "string" && typeof relation.id === "string") {
|
|||
|
|
return `${relation.type}: ${relation.id}`;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return "";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function relationKey(relation, index) {
|
|||
|
|
const safeType = String(relation?.type || "relation");
|
|||
|
|
const safeId = String(relation?.id || index || "0");
|
|||
|
|
const safeLabel = String(relation?.label || relation?.text || "");
|
|||
|
|
return `${safeType}|${safeId}|${safeLabel}`;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function normalizeRelationObject(relation, index) {
|
|||
|
|
if (relation && typeof relation === "object") {
|
|||
|
|
const label = formatRelation(relation);
|
|||
|
|
if (!label) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return {
|
|||
|
|
...relation,
|
|||
|
|
label,
|
|||
|
|
__key: relationKey(relation, index)
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const text = formatRelation(relation);
|
|||
|
|
if (!text) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return {
|
|||
|
|
type: "text",
|
|||
|
|
id: `text-${index}`,
|
|||
|
|
label: text,
|
|||
|
|
data: { value: text },
|
|||
|
|
__key: relationKey({ type: "text", id: `text-${index}`, label: text }, index)
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function formatRelationDataLines(relation) {
|
|||
|
|
if (!relation || typeof relation !== "object") {
|
|||
|
|
return "--";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const data = relation.data;
|
|||
|
|
if (!data || typeof data !== "object") {
|
|||
|
|
return "(no additional relation data)";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const lines = Object.entries(data)
|
|||
|
|
.filter(([, value]) => value !== null && value !== undefined && String(value).trim() !== "")
|
|||
|
|
.map(([key, value]) => `${key}: ${value}`);
|
|||
|
|
|
|||
|
|
return lines.length ? lines.join("\n") : "(no additional relation data)";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function buildCubeFaceRelationsForCard(card) {
|
|||
|
|
const cube = state.magickDataset?.grouped?.kabbalah?.cube;
|
|||
|
|
const walls = Array.isArray(cube?.walls) ? cube.walls : [];
|
|||
|
|
if (!card || !walls.length) {
|
|||
|
|
return [];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return walls
|
|||
|
|
.map((wall, index) => {
|
|||
|
|
const wallTarot = wall?.associations?.tarotCard || wall?.tarotCard;
|
|||
|
|
if (!wallTarot || !cardMatchesTarotAssociation(card, wallTarot)) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const wallId = String(wall?.id || "").trim();
|
|||
|
|
const wallName = String(wall?.name || wallId || "").trim();
|
|||
|
|
if (!wallId) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return {
|
|||
|
|
type: "cubeFace",
|
|||
|
|
id: wallId,
|
|||
|
|
label: `Cube: ${wallName} Wall - Face`,
|
|||
|
|
data: {
|
|||
|
|
wallId,
|
|||
|
|
wallName,
|
|||
|
|
edgeId: ""
|
|||
|
|
},
|
|||
|
|
__key: `cubeFace|${wallId}|${index}`
|
|||
|
|
};
|
|||
|
|
})
|
|||
|
|
.filter(Boolean);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function cardMatchesPathTarot(card, path) {
|
|||
|
|
if (!card || !path) {
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const trumpNumber = Number(path?.tarot?.trumpNumber);
|
|||
|
|
if (card?.arcana === "Major" && Number.isFinite(Number(card?.number)) && Number.isFinite(trumpNumber)) {
|
|||
|
|
if (Number(card.number) === trumpNumber) {
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return cardMatchesTarotAssociation(card, path?.tarot?.card);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function buildCubeEdgeRelationsForCard(card) {
|
|||
|
|
const cube = state.magickDataset?.grouped?.kabbalah?.cube;
|
|||
|
|
const tree = state.magickDataset?.grouped?.kabbalah?.["kabbalah-tree"];
|
|||
|
|
const edges = Array.isArray(cube?.edges) ? cube.edges : [];
|
|||
|
|
const paths = Array.isArray(tree?.paths) ? tree.paths : [];
|
|||
|
|
|
|||
|
|
if (!card || !edges.length || !paths.length) {
|
|||
|
|
return [];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const pathByLetterId = new Map(
|
|||
|
|
paths
|
|||
|
|
.map((path) => [normalizeHebrewLetterId(path?.hebrewLetter?.transliteration), path])
|
|||
|
|
.filter(([letterId]) => Boolean(letterId))
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
return edges
|
|||
|
|
.map((edge, index) => {
|
|||
|
|
const edgeLetterId = normalizeHebrewLetterId(edge?.hebrewLetterId || edge?.associations?.hebrewLetterId);
|
|||
|
|
if (!edgeLetterId) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const pathMatch = pathByLetterId.get(edgeLetterId);
|
|||
|
|
if (!pathMatch || !cardMatchesPathTarot(card, pathMatch)) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const edgeId = String(edge?.id || "").trim();
|
|||
|
|
if (!edgeId) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const edgeName = String(edge?.name || edgeId).trim();
|
|||
|
|
const wallId = String(Array.isArray(edge?.walls) ? (edge.walls[0] || "") : "").trim();
|
|||
|
|
|
|||
|
|
return {
|
|||
|
|
type: "cubeEdge",
|
|||
|
|
id: edgeId,
|
|||
|
|
label: `Cube: ${edgeName} Edge`,
|
|||
|
|
data: {
|
|||
|
|
edgeId,
|
|||
|
|
edgeName,
|
|||
|
|
wallId: wallId || undefined,
|
|||
|
|
hebrewLetterId: edgeLetterId
|
|||
|
|
},
|
|||
|
|
__key: `cubeEdge|${edgeId}|${index}`
|
|||
|
|
};
|
|||
|
|
})
|
|||
|
|
.filter(Boolean);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function buildCubeMotherConnectorRelationsForCard(card) {
|
|||
|
|
const tree = state.magickDataset?.grouped?.kabbalah?.["kabbalah-tree"];
|
|||
|
|
const paths = Array.isArray(tree?.paths) ? tree.paths : [];
|
|||
|
|
const relations = Array.isArray(card?.relations) ? card.relations : [];
|
|||
|
|
|
|||
|
|
return Object.entries(CUBE_MOTHER_CONNECTOR_BY_LETTER)
|
|||
|
|
.map(([letterId, connector]) => {
|
|||
|
|
const pathMatch = paths.find((path) => normalizeHebrewLetterId(path?.hebrewLetter?.transliteration) === letterId) || null;
|
|||
|
|
|
|||
|
|
const matchesByPath = cardMatchesPathTarot(card, pathMatch);
|
|||
|
|
|
|||
|
|
const matchesByHebrewRelation = relations.some((relation) => {
|
|||
|
|
if (relation?.type !== "hebrewLetter") {
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
const relationLetterId = normalizeHebrewLetterId(
|
|||
|
|
relation?.data?.id || relation?.id || relation?.data?.latin || relation?.data?.name
|
|||
|
|
);
|
|||
|
|
return relationLetterId === letterId;
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
if (!matchesByPath && !matchesByHebrewRelation) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return {
|
|||
|
|
type: "cubeConnector",
|
|||
|
|
id: connector.connectorId,
|
|||
|
|
label: `Cube: ${connector.connectorName}`,
|
|||
|
|
data: {
|
|||
|
|
connectorId: connector.connectorId,
|
|||
|
|
connectorName: connector.connectorName,
|
|||
|
|
hebrewLetterId: letterId
|
|||
|
|
},
|
|||
|
|
__key: `cubeConnector|${connector.connectorId}|${letterId}`
|
|||
|
|
};
|
|||
|
|
})
|
|||
|
|
.filter(Boolean);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function buildCubePrimalPointRelationsForCard(card) {
|
|||
|
|
const center = state.magickDataset?.grouped?.kabbalah?.cube?.center;
|
|||
|
|
if (!center || !card) {
|
|||
|
|
return [];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const centerTarot = center?.associations?.tarotCard || center?.tarotCard;
|
|||
|
|
const centerTrump = Number(center?.associations?.tarotTrumpNumber);
|
|||
|
|
const matchesByName = cardMatchesTarotAssociation(card, centerTarot);
|
|||
|
|
const matchesByTrump = card?.arcana === "Major"
|
|||
|
|
&& Number.isFinite(Number(card?.number))
|
|||
|
|
&& Number.isFinite(centerTrump)
|
|||
|
|
&& Number(card.number) === centerTrump;
|
|||
|
|
|
|||
|
|
if (!matchesByName && !matchesByTrump) {
|
|||
|
|
return [];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return [{
|
|||
|
|
type: "cubeCenter",
|
|||
|
|
id: "primal-point",
|
|||
|
|
label: "Cube: Primal Point",
|
|||
|
|
data: {
|
|||
|
|
nodeType: "center",
|
|||
|
|
primalPoint: true
|
|||
|
|
},
|
|||
|
|
__key: "cubeCenter|primal-point"
|
|||
|
|
}];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function buildCubeRelationsForCard(card) {
|
|||
|
|
return [
|
|||
|
|
...buildCubeFaceRelationsForCard(card),
|
|||
|
|
...buildCubeEdgeRelationsForCard(card),
|
|||
|
|
...buildCubePrimalPointRelationsForCard(card),
|
|||
|
|
...buildCubeMotherConnectorRelationsForCard(card)
|
|||
|
|
];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Returns nav dispatch config for relations that have a corresponding section,
|
|||
|
|
// null for informational-only relations.
|
|||
|
|
function getRelationNavTarget(relation) {
|
|||
|
|
const t = relation?.type;
|
|||
|
|
const d = relation?.data || {};
|
|||
|
|
if ((t === "planetCorrespondence" || t === "decanRuler") && d.planetId) {
|
|||
|
|
return {
|
|||
|
|
event: "nav:planet",
|
|||
|
|
detail: { planetId: d.planetId },
|
|||
|
|
label: `Open ${d.name || d.planetId} in Planets`
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
if (t === "planet") {
|
|||
|
|
const planetId = normalizeRelationId(d.name || relation?.id || "");
|
|||
|
|
if (!planetId) return null;
|
|||
|
|
return {
|
|||
|
|
event: "nav:planet",
|
|||
|
|
detail: { planetId },
|
|||
|
|
label: `Open ${d.name || planetId} in Planets`
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
if (t === "element") {
|
|||
|
|
const elementId = d.elementId || relation?.id;
|
|||
|
|
if (!elementId) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
return {
|
|||
|
|
event: "nav:elements",
|
|||
|
|
detail: { elementId },
|
|||
|
|
label: `Open ${d.name || elementId} in Elements`
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
if (t === "tetragrammaton") {
|
|||
|
|
if (!d.hebrewLetterId) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
return {
|
|||
|
|
event: "nav:alphabet",
|
|||
|
|
detail: { alphabet: "hebrew", hebrewLetterId: d.hebrewLetterId },
|
|||
|
|
label: `Open ${d.letter || d.hebrewLetterId} in Alphabet`
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
if (t === "tarotCard") {
|
|||
|
|
const cardName = d.cardName || relation?.id;
|
|||
|
|
if (!cardName) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
return {
|
|||
|
|
event: "nav:tarot-trump",
|
|||
|
|
detail: { cardName },
|
|||
|
|
label: `Open ${cardName} in Tarot`
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
if (t === "zodiacRulership") {
|
|||
|
|
const signId = d.signId || relation?.id;
|
|||
|
|
if (!signId) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
return {
|
|||
|
|
event: "nav:zodiac",
|
|||
|
|
detail: { signId },
|
|||
|
|
label: `Open ${d.signName || signId} in Zodiac`
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
if (t === "zodiacCorrespondence" || t === "zodiac") {
|
|||
|
|
const signId = d.signId || relation?.id || normalizeRelationId(d.name || "");
|
|||
|
|
if (!signId) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
return {
|
|||
|
|
event: "nav:zodiac",
|
|||
|
|
detail: { signId },
|
|||
|
|
label: `Open ${d.name || signId} in Zodiac`
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
if (t === "decan") {
|
|||
|
|
const signId = d.signId || normalizeRelationId(d.signName || relation?.id || "");
|
|||
|
|
if (!signId) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
return {
|
|||
|
|
event: "nav:zodiac",
|
|||
|
|
detail: { signId },
|
|||
|
|
label: `Open ${d.signName || signId} in Zodiac`
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
if (t === "hebrewLetter") {
|
|||
|
|
const hebrewLetterId = d.id || relation?.id;
|
|||
|
|
if (!hebrewLetterId) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
return {
|
|||
|
|
event: "nav:alphabet",
|
|||
|
|
detail: { alphabet: "hebrew", hebrewLetterId },
|
|||
|
|
label: `Open ${d.name || hebrewLetterId} in Alphabet`
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
if (t === "calendarMonth") {
|
|||
|
|
const monthId = d.monthId || relation?.id;
|
|||
|
|
if (!monthId) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
return {
|
|||
|
|
event: "nav:calendar-month",
|
|||
|
|
detail: { monthId },
|
|||
|
|
label: `Open ${d.name || monthId} in Calendar`
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
if (t === "cubeFace") {
|
|||
|
|
const wallId = d.wallId || relation?.id;
|
|||
|
|
if (!wallId) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
return {
|
|||
|
|
event: "nav:cube",
|
|||
|
|
detail: { wallId, edgeId: "" },
|
|||
|
|
label: `Open ${d.wallName || wallId} face in Cube`
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
if (t === "cubeEdge") {
|
|||
|
|
const edgeId = d.edgeId || relation?.id;
|
|||
|
|
if (!edgeId) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
return {
|
|||
|
|
event: "nav:cube",
|
|||
|
|
detail: { edgeId, wallId: d.wallId || undefined },
|
|||
|
|
label: `Open ${d.edgeName || edgeId} edge in Cube`
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
if (t === "cubeConnector") {
|
|||
|
|
const connectorId = d.connectorId || relation?.id;
|
|||
|
|
if (!connectorId) {
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
return {
|
|||
|
|
event: "nav:cube",
|
|||
|
|
detail: { connectorId },
|
|||
|
|
label: `Open ${d.connectorName || connectorId} connector in Cube`
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
if (t === "cubeCenter") {
|
|||
|
|
return {
|
|||
|
|
event: "nav:cube",
|
|||
|
|
detail: { nodeType: "center", primalPoint: true },
|
|||
|
|
label: "Open Primal Point in Cube"
|
|||
|
|
};
|
|||
|
|
}
|
|||
|
|
return null;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function createRelationListItem(relation) {
|
|||
|
|
const item = document.createElement("li");
|
|||
|
|
const navTarget = getRelationNavTarget(relation);
|
|||
|
|
|
|||
|
|
const button = document.createElement("button");
|
|||
|
|
button.type = "button";
|
|||
|
|
button.className = "tarot-relation-btn";
|
|||
|
|
button.dataset.relationKey = relation.__key;
|
|||
|
|
button.textContent = relation.label;
|
|||
|
|
item.appendChild(button);
|
|||
|
|
|
|||
|
|
if (!navTarget) {
|
|||
|
|
button.classList.add("tarot-relation-btn-static");
|
|||
|
|
}
|
|||
|
|
button.addEventListener("click", () => {
|
|||
|
|
if (navTarget) {
|
|||
|
|
document.dispatchEvent(new CustomEvent(navTarget.event, { detail: navTarget.detail }));
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
if (navTarget) {
|
|||
|
|
item.className = "tarot-rel-item";
|
|||
|
|
const navBtn = document.createElement("button");
|
|||
|
|
navBtn.type = "button";
|
|||
|
|
navBtn.className = "tarot-rel-nav-btn";
|
|||
|
|
navBtn.title = navTarget.label;
|
|||
|
|
navBtn.textContent = "\u2197";
|
|||
|
|
navBtn.addEventListener("click", (e) => {
|
|||
|
|
e.stopPropagation();
|
|||
|
|
document.dispatchEvent(new CustomEvent(navTarget.event, { detail: navTarget.detail }));
|
|||
|
|
});
|
|||
|
|
item.appendChild(navBtn);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return item;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function renderStaticRelationGroup(targetEl, cardEl, relations) {
|
|||
|
|
clearChildren(targetEl);
|
|||
|
|
if (!targetEl || !cardEl) return;
|
|||
|
|
if (!relations.length) {
|
|||
|
|
cardEl.hidden = true;
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
cardEl.hidden = false;
|
|||
|
|
|
|||
|
|
relations.forEach((relation) => {
|
|||
|
|
targetEl.appendChild(createRelationListItem(relation));
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function renderDetail(card, elements) {
|
|||
|
|
if (!card || !elements) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const cardDisplayName = getDisplayCardName(card);
|
|||
|
|
const imageUrl = typeof resolveTarotCardImage === "function"
|
|||
|
|
? resolveTarotCardImage(card.name)
|
|||
|
|
: null;
|
|||
|
|
|
|||
|
|
if (elements.tarotDetailImageEl) {
|
|||
|
|
if (imageUrl) {
|
|||
|
|
elements.tarotDetailImageEl.src = imageUrl;
|
|||
|
|
elements.tarotDetailImageEl.alt = cardDisplayName || card.name;
|
|||
|
|
elements.tarotDetailImageEl.style.display = "block";
|
|||
|
|
elements.tarotDetailImageEl.style.cursor = "zoom-in";
|
|||
|
|
elements.tarotDetailImageEl.title = "Click to enlarge";
|
|||
|
|
} else {
|
|||
|
|
elements.tarotDetailImageEl.removeAttribute("src");
|
|||
|
|
elements.tarotDetailImageEl.alt = "";
|
|||
|
|
elements.tarotDetailImageEl.style.display = "none";
|
|||
|
|
elements.tarotDetailImageEl.style.cursor = "default";
|
|||
|
|
elements.tarotDetailImageEl.removeAttribute("title");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (elements.tarotDetailNameEl) {
|
|||
|
|
elements.tarotDetailNameEl.textContent = cardDisplayName || card.name;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (elements.tarotDetailTypeEl) {
|
|||
|
|
elements.tarotDetailTypeEl.textContent = buildTypeLabel(card);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (elements.tarotDetailSummaryEl) {
|
|||
|
|
elements.tarotDetailSummaryEl.textContent = card.summary || "--";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (elements.tarotDetailUprightEl) {
|
|||
|
|
elements.tarotDetailUprightEl.textContent = card.meanings?.upright || "--";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (elements.tarotDetailReversedEl) {
|
|||
|
|
elements.tarotDetailReversedEl.textContent = card.meanings?.reversed || "--";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const meaningText = String(card.meaning || card.meanings?.upright || "").trim();
|
|||
|
|
if (elements.tarotMetaMeaningCardEl && elements.tarotDetailMeaningEl) {
|
|||
|
|
if (meaningText) {
|
|||
|
|
elements.tarotMetaMeaningCardEl.hidden = false;
|
|||
|
|
elements.tarotDetailMeaningEl.textContent = meaningText;
|
|||
|
|
} else {
|
|||
|
|
elements.tarotMetaMeaningCardEl.hidden = true;
|
|||
|
|
elements.tarotDetailMeaningEl.textContent = "--";
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
clearChildren(elements.tarotDetailKeywordsEl);
|
|||
|
|
(card.keywords || []).forEach((keyword) => {
|
|||
|
|
const chip = document.createElement("span");
|
|||
|
|
chip.className = "tarot-keyword-chip";
|
|||
|
|
chip.textContent = keyword;
|
|||
|
|
elements.tarotDetailKeywordsEl?.appendChild(chip);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
const allRelations = (card.relations || [])
|
|||
|
|
.map((relation, index) => normalizeRelationObject(relation, index))
|
|||
|
|
.filter(Boolean);
|
|||
|
|
|
|||
|
|
const uniqueByKey = new Set();
|
|||
|
|
const dedupedRelations = allRelations.filter((relation) => {
|
|||
|
|
const key = `${relation.type || "relation"}|${relation.id || ""}|${relation.label || ""}`;
|
|||
|
|
if (uniqueByKey.has(key)) return false;
|
|||
|
|
uniqueByKey.add(key);
|
|||
|
|
return true;
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
const planetRelations = dedupedRelations.filter((relation) =>
|
|||
|
|
relation.type === "planetCorrespondence" || relation.type === "decanRuler" || relation.type === "planet"
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
const zodiacRelations = dedupedRelations.filter((relation) =>
|
|||
|
|
relation.type === "zodiacCorrespondence" || relation.type === "zodiac" || relation.type === "decan"
|
|||
|
|
);
|
|||
|
|
|
|||
|
|
const courtDateRelations = dedupedRelations.filter((relation) => relation.type === "courtDateWindow");
|
|||
|
|
|
|||
|
|
const hebrewRelations = dedupedRelations.filter((relation) => relation.type === "hebrewLetter");
|
|||
|
|
const baseElementRelations = dedupedRelations.filter((relation) => relation.type === "element");
|
|||
|
|
const elementRelations = buildElementRelationsForCard(card, baseElementRelations);
|
|||
|
|
const tetragrammatonRelations = buildTetragrammatonRelationsForCard(card);
|
|||
|
|
const smallCardRulershipRelation = buildSmallCardRulershipRelation(card);
|
|||
|
|
const zodiacRelationsWithRulership = smallCardRulershipRelation
|
|||
|
|
? [...zodiacRelations, smallCardRulershipRelation]
|
|||
|
|
: zodiacRelations;
|
|||
|
|
const smallCardCourtLinkRelations = buildSmallCardCourtLinkRelations(card, dedupedRelations);
|
|||
|
|
const mergedCourtDateRelations = [...courtDateRelations, ...smallCardCourtLinkRelations];
|
|||
|
|
const cubeRelations = buildCubeRelationsForCard(card);
|
|||
|
|
const monthRelations = (state.monthRefsByCardId.get(card.id) || []).map((month, index) => {
|
|||
|
|
const dateRange = String(month?.dateRange || "").trim();
|
|||
|
|
const context = String(month?.context || "").trim();
|
|||
|
|
const labelBase = dateRange || month.name;
|
|||
|
|
const label = context ? `${labelBase} · ${context}` : labelBase;
|
|||
|
|
|
|||
|
|
return {
|
|||
|
|
type: "calendarMonth",
|
|||
|
|
id: month.id,
|
|||
|
|
label,
|
|||
|
|
data: {
|
|||
|
|
monthId: month.id,
|
|||
|
|
name: month.name,
|
|||
|
|
monthOrder: Number.isFinite(Number(month.order)) ? Number(month.order) : null,
|
|||
|
|
dateRange: dateRange || null,
|
|||
|
|
dateStart: month.startToken || null,
|
|||
|
|
dateEnd: month.endToken || null,
|
|||
|
|
context: context || null,
|
|||
|
|
source: month.source || null
|
|||
|
|
},
|
|||
|
|
__key: `calendarMonth|${month.id}|${month.uniqueKey || index}`
|
|||
|
|
};
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
const relationMonthRows = dedupedRelations
|
|||
|
|
.filter((relation) => relation.type === "calendarMonth")
|
|||
|
|
.map((relation) => {
|
|||
|
|
const dateRange = String(relation?.data?.dateRange || "").trim();
|
|||
|
|
const baseName = relation?.data?.name || relation.label;
|
|||
|
|
const label = dateRange && baseName
|
|||
|
|
? `${baseName} · ${dateRange}`
|
|||
|
|
: baseName;
|
|||
|
|
|
|||
|
|
return {
|
|||
|
|
type: "calendarMonth",
|
|||
|
|
id: relation?.data?.monthId || relation.id,
|
|||
|
|
label,
|
|||
|
|
data: {
|
|||
|
|
monthId: relation?.data?.monthId || relation.id,
|
|||
|
|
name: relation?.data?.name || relation.label,
|
|||
|
|
monthOrder: Number.isFinite(Number(relation?.data?.monthOrder))
|
|||
|
|
? Number(relation.data.monthOrder)
|
|||
|
|
: null,
|
|||
|
|
dateRange: dateRange || null,
|
|||
|
|
dateStart: relation?.data?.dateStart || null,
|
|||
|
|
dateEnd: relation?.data?.dateEnd || null,
|
|||
|
|
context: relation?.data?.signName || null
|
|||
|
|
},
|
|||
|
|
__key: relation.__key
|
|||
|
|
};
|
|||
|
|
})
|
|||
|
|
.filter((entry) => entry.data.monthId);
|
|||
|
|
|
|||
|
|
const mergedMonthMap = new Map();
|
|||
|
|
[...monthRelations, ...relationMonthRows].forEach((entry) => {
|
|||
|
|
const monthId = entry?.data?.monthId;
|
|||
|
|
if (!monthId) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const key = [
|
|||
|
|
monthId,
|
|||
|
|
String(entry?.data?.dateRange || "").trim().toLowerCase(),
|
|||
|
|
String(entry?.data?.context || "").trim().toLowerCase(),
|
|||
|
|
String(entry?.label || "").trim().toLowerCase()
|
|||
|
|
].join("|");
|
|||
|
|
|
|||
|
|
if (!mergedMonthMap.has(key)) {
|
|||
|
|
mergedMonthMap.set(key, entry);
|
|||
|
|
}
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
const mergedMonthRelations = [...mergedMonthMap.values()].sort((left, right) => {
|
|||
|
|
const orderLeft = Number.isFinite(Number(left?.data?.monthOrder)) ? Number(left.data.monthOrder) : 999;
|
|||
|
|
const orderRight = Number.isFinite(Number(right?.data?.monthOrder)) ? Number(right.data.monthOrder) : 999;
|
|||
|
|
|
|||
|
|
if (orderLeft !== orderRight) {
|
|||
|
|
return orderLeft - orderRight;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const startLeft = parseMonthDayToken(left?.data?.dateStart);
|
|||
|
|
const startRight = parseMonthDayToken(right?.data?.dateStart);
|
|||
|
|
const dayLeft = startLeft ? startLeft.day : 999;
|
|||
|
|
const dayRight = startRight ? startRight.day : 999;
|
|||
|
|
if (dayLeft !== dayRight) {
|
|||
|
|
return dayLeft - dayRight;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return String(left.label || "").localeCompare(String(right.label || ""));
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
renderStaticRelationGroup(elements.tarotDetailPlanetEl, elements.tarotMetaPlanetCardEl, planetRelations);
|
|||
|
|
renderStaticRelationGroup(elements.tarotDetailElementEl, elements.tarotMetaElementCardEl, elementRelations);
|
|||
|
|
renderStaticRelationGroup(elements.tarotDetailTetragrammatonEl, elements.tarotMetaTetragrammatonCardEl, tetragrammatonRelations);
|
|||
|
|
renderStaticRelationGroup(elements.tarotDetailZodiacEl, elements.tarotMetaZodiacCardEl, zodiacRelationsWithRulership);
|
|||
|
|
renderStaticRelationGroup(elements.tarotDetailCourtDateEl, elements.tarotMetaCourtDateCardEl, mergedCourtDateRelations);
|
|||
|
|
renderStaticRelationGroup(elements.tarotDetailHebrewEl, elements.tarotMetaHebrewCardEl, hebrewRelations);
|
|||
|
|
renderStaticRelationGroup(elements.tarotDetailCubeEl, elements.tarotMetaCubeCardEl, cubeRelations);
|
|||
|
|
renderStaticRelationGroup(elements.tarotDetailCalendarEl, elements.tarotMetaCalendarCardEl, mergedMonthRelations);
|
|||
|
|
|
|||
|
|
// ── Kabbalah Tree path cross-reference ─────────────────────────────────
|
|||
|
|
const kabPathEl = elements.tarotKabPathEl;
|
|||
|
|
if (kabPathEl) {
|
|||
|
|
const kabTree = state.magickDataset?.grouped?.kabbalah?.["kabbalah-tree"];
|
|||
|
|
const kabPath = (card.arcana === "Major" && typeof card.number === "number" && kabTree)
|
|||
|
|
? kabTree.paths.find(p => p.tarot?.trumpNumber === card.number)
|
|||
|
|
: null;
|
|||
|
|
const kabSeph = !kabPath ? findSephirahForMinorCard(card, kabTree) : null;
|
|||
|
|
|
|||
|
|
if (kabPath) {
|
|||
|
|
const letter = kabPath.hebrewLetter || {};
|
|||
|
|
const fromName = kabTree.sephiroth.find(s => s.number === kabPath.connects.from)?.name || kabPath.connects.from;
|
|||
|
|
const toName = kabTree.sephiroth.find(s => s.number === kabPath.connects.to)?.name || kabPath.connects.to;
|
|||
|
|
const astro = kabPath.astrology ? `${kabPath.astrology.name} (${kabPath.astrology.type})` : "";
|
|||
|
|
|
|||
|
|
kabPathEl.innerHTML = `
|
|||
|
|
<strong>Kabbalah Tree — Path ${kabPath.pathNumber}</strong>
|
|||
|
|
<div class="tarot-kab-path-row">
|
|||
|
|
<span class="tarot-kab-letter" title="${letter.transliteration || ""}">${letter.char || ""}</span>
|
|||
|
|
<span class="tarot-kab-meta">
|
|||
|
|
<span class="tarot-kab-name">${letter.transliteration || ""} — “${letter.meaning || ""}” · ${letter.letterType || ""}</span>
|
|||
|
|
<span class="tarot-kab-connects">${fromName} → ${toName}${astro ? " · " + astro : ""}</span>
|
|||
|
|
</span>
|
|||
|
|
</div>`;
|
|||
|
|
|
|||
|
|
const btn = document.createElement("button");
|
|||
|
|
btn.type = "button";
|
|||
|
|
btn.className = "kab-tarot-link";
|
|||
|
|
btn.textContent = `View Path ${kabPath.pathNumber} in Kabbalah Tree`;
|
|||
|
|
btn.addEventListener("click", () => {
|
|||
|
|
document.dispatchEvent(new CustomEvent("tarot:view-kab-path", {
|
|||
|
|
detail: { pathNumber: kabPath.pathNumber }
|
|||
|
|
}));
|
|||
|
|
});
|
|||
|
|
kabPathEl.appendChild(btn);
|
|||
|
|
kabPathEl.hidden = false;
|
|||
|
|
} else if (kabSeph) {
|
|||
|
|
const hebrewName = kabSeph.nameHebrew ? ` (${kabSeph.nameHebrew})` : "";
|
|||
|
|
const translation = kabSeph.translation ? ` — ${kabSeph.translation}` : "";
|
|||
|
|
const planetInfo = kabSeph.planet || "";
|
|||
|
|
const tarotInfo = kabSeph.tarot ? ` · ${kabSeph.tarot}` : "";
|
|||
|
|
|
|||
|
|
kabPathEl.innerHTML = `
|
|||
|
|
<strong>Kabbalah Tree — Sephirah ${kabSeph.number}</strong>
|
|||
|
|
<div class="tarot-kab-path-row">
|
|||
|
|
<span class="tarot-kab-letter" title="${kabSeph.name || ""}">${kabSeph.number}</span>
|
|||
|
|
<span class="tarot-kab-meta">
|
|||
|
|
<span class="tarot-kab-name">${kabSeph.name || ""}${hebrewName}${translation}</span>
|
|||
|
|
<span class="tarot-kab-connects">${planetInfo}${tarotInfo}</span>
|
|||
|
|
</span>
|
|||
|
|
</div>`;
|
|||
|
|
|
|||
|
|
const btn = document.createElement("button");
|
|||
|
|
btn.type = "button";
|
|||
|
|
btn.className = "kab-tarot-link";
|
|||
|
|
btn.textContent = `View Sephirah ${kabSeph.number} in Kabbalah Tree`;
|
|||
|
|
btn.addEventListener("click", () => {
|
|||
|
|
document.dispatchEvent(new CustomEvent("tarot:view-kab-path", {
|
|||
|
|
detail: { pathNumber: kabSeph.number }
|
|||
|
|
}));
|
|||
|
|
});
|
|||
|
|
kabPathEl.appendChild(btn);
|
|||
|
|
kabPathEl.hidden = false;
|
|||
|
|
} else {
|
|||
|
|
kabPathEl.hidden = true;
|
|||
|
|
kabPathEl.innerHTML = "";
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function updateListSelection(elements) {
|
|||
|
|
if (!elements?.tarotCardListEl) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const buttons = elements.tarotCardListEl.querySelectorAll(".tarot-list-item");
|
|||
|
|
buttons.forEach((button) => {
|
|||
|
|
const isSelected = button.dataset.cardId === state.selectedCardId;
|
|||
|
|
button.classList.toggle("is-selected", isSelected);
|
|||
|
|
button.setAttribute("aria-selected", isSelected ? "true" : "false");
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function selectCardById(cardIdToSelect, elements) {
|
|||
|
|
const card = state.cards.find((entry) => entry.id === cardIdToSelect);
|
|||
|
|
if (!card) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
state.selectedCardId = card.id;
|
|||
|
|
updateListSelection(elements);
|
|||
|
|
updateHouseSelection(elements);
|
|||
|
|
renderDetail(card, elements);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function renderList(elements) {
|
|||
|
|
if (!elements?.tarotCardListEl) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
clearChildren(elements.tarotCardListEl);
|
|||
|
|
|
|||
|
|
state.filteredCards.forEach((card) => {
|
|||
|
|
const cardDisplayName = getDisplayCardName(card);
|
|||
|
|
const button = document.createElement("button");
|
|||
|
|
button.type = "button";
|
|||
|
|
button.className = "tarot-list-item";
|
|||
|
|
button.dataset.cardId = card.id;
|
|||
|
|
button.setAttribute("role", "option");
|
|||
|
|
|
|||
|
|
const nameEl = document.createElement("span");
|
|||
|
|
nameEl.className = "tarot-list-name";
|
|||
|
|
nameEl.textContent = cardDisplayName || card.name;
|
|||
|
|
|
|||
|
|
const metaEl = document.createElement("span");
|
|||
|
|
metaEl.className = "tarot-list-meta";
|
|||
|
|
metaEl.textContent = buildTypeLabel(card);
|
|||
|
|
|
|||
|
|
button.append(nameEl, metaEl);
|
|||
|
|
elements.tarotCardListEl.appendChild(button);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
if (elements.tarotCountEl) {
|
|||
|
|
elements.tarotCountEl.textContent = state.searchQuery
|
|||
|
|
? `${state.filteredCards.length} of ${state.cards.length} cards`
|
|||
|
|
: `${state.cards.length} cards`;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function ensureTarotSection(referenceData, magickDataset = null) {
|
|||
|
|
state.referenceData = referenceData || state.referenceData;
|
|||
|
|
|
|||
|
|
if (magickDataset) {
|
|||
|
|
state.magickDataset = magickDataset;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const elements = getElements();
|
|||
|
|
|
|||
|
|
if (state.initialized) {
|
|||
|
|
state.monthRefsByCardId = buildMonthReferencesByCard(referenceData, state.cards);
|
|||
|
|
state.courtCardByDecanId = buildCourtCardByDecanId(state.cards);
|
|||
|
|
renderHouseOfCards(elements);
|
|||
|
|
if (state.selectedCardId) {
|
|||
|
|
const selected = state.cards.find((card) => card.id === state.selectedCardId);
|
|||
|
|
if (selected) {
|
|||
|
|
renderDetail(selected, elements);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (!elements.tarotCardListEl || !elements.tarotDetailNameEl) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const databaseBuilder = window.TarotCardDatabase?.buildTarotDatabase;
|
|||
|
|
if (typeof databaseBuilder !== "function") {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const cards = databaseBuilder(referenceData, magickDataset).map((card) => ({
|
|||
|
|
...card,
|
|||
|
|
id: cardId(card)
|
|||
|
|
}));
|
|||
|
|
|
|||
|
|
state.cards = cards;
|
|||
|
|
state.monthRefsByCardId = buildMonthReferencesByCard(referenceData, cards);
|
|||
|
|
state.courtCardByDecanId = buildCourtCardByDecanId(cards);
|
|||
|
|
state.filteredCards = [...cards];
|
|||
|
|
renderList(elements);
|
|||
|
|
renderHouseOfCards(elements);
|
|||
|
|
|
|||
|
|
if (cards.length > 0) {
|
|||
|
|
selectCardById(cards[0].id, elements);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
elements.tarotCardListEl.addEventListener("click", (event) => {
|
|||
|
|
const target = event.target;
|
|||
|
|
if (!(target instanceof Node)) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const button = target instanceof Element
|
|||
|
|
? target.closest(".tarot-list-item")
|
|||
|
|
: null;
|
|||
|
|
|
|||
|
|
if (!(button instanceof HTMLButtonElement)) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
const selectedId = button.dataset.cardId;
|
|||
|
|
if (!selectedId) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
selectCardById(selectedId, elements);
|
|||
|
|
});
|
|||
|
|
|
|||
|
|
if (elements.tarotSearchInputEl) {
|
|||
|
|
elements.tarotSearchInputEl.addEventListener("input", () => {
|
|||
|
|
state.searchQuery = elements.tarotSearchInputEl.value || "";
|
|||
|
|
applySearchFilter(elements);
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (elements.tarotSearchClearEl && elements.tarotSearchInputEl) {
|
|||
|
|
elements.tarotSearchClearEl.addEventListener("click", () => {
|
|||
|
|
elements.tarotSearchInputEl.value = "";
|
|||
|
|
state.searchQuery = "";
|
|||
|
|
applySearchFilter(elements);
|
|||
|
|
elements.tarotSearchInputEl.focus();
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (elements.tarotDetailImageEl) {
|
|||
|
|
elements.tarotDetailImageEl.addEventListener("click", () => {
|
|||
|
|
const src = elements.tarotDetailImageEl.getAttribute("src") || "";
|
|||
|
|
if (!src || elements.tarotDetailImageEl.style.display === "none") {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
openTarotImageLightbox(src, elements.tarotDetailImageEl.alt || "Tarot card enlarged image");
|
|||
|
|
});
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
state.initialized = true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function selectCardByTrump(trumpNumber) {
|
|||
|
|
if (!state.initialized) return;
|
|||
|
|
const el = getElements();
|
|||
|
|
const card = state.cards.find(c => c.arcana === "Major" && c.number === trumpNumber);
|
|||
|
|
if (!card) return;
|
|||
|
|
selectCardById(card.id, el);
|
|||
|
|
const listItem = el.tarotCardListEl?.querySelector(`[data-card-id="${card.id}"]`);
|
|||
|
|
listItem?.scrollIntoView({ block: "nearest" });
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
function selectCardByName(name) {
|
|||
|
|
if (!state.initialized) return;
|
|||
|
|
const el = getElements();
|
|||
|
|
const needle = normalizeTarotCardLookupName(name);
|
|||
|
|
const card = state.cards.find((entry) => normalizeTarotCardLookupName(entry.name) === needle);
|
|||
|
|
if (!card) return;
|
|||
|
|
selectCardById(card.id, el);
|
|||
|
|
el.tarotCardListEl
|
|||
|
|
?.querySelector(`[data-card-id="${card.id}"]`)
|
|||
|
|
?.scrollIntoView({ block: "nearest" });
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
window.TarotSectionUi = {
|
|||
|
|
ensureTarotSection,
|
|||
|
|
selectCardByTrump,
|
|||
|
|
selectCardByName,
|
|||
|
|
getCards: () => state.cards
|
|||
|
|
};
|
|||
|
|
})();
|