635 lines
20 KiB
JavaScript
635 lines
20 KiB
JavaScript
(function () {
|
|
"use strict";
|
|
|
|
const SETTINGS_STORAGE_KEY = "tarot-time-settings-v1";
|
|
|
|
let config = {
|
|
defaultSettings: {
|
|
latitude: 51.5074,
|
|
longitude: -0.1278,
|
|
timeFormat: "minutes",
|
|
birthDate: "",
|
|
tarotDeck: "ceremonial-magick",
|
|
stellariumBackgroundEnabled: false,
|
|
hasExplicitLocation: false
|
|
},
|
|
onSettingsApplied: null,
|
|
onSyncSkyBackground: null,
|
|
onStatus: null,
|
|
onConnectionSaved: null,
|
|
onReopenActiveSection: null,
|
|
setActiveSection: null,
|
|
getActiveSection: null,
|
|
onRenderWeek: null
|
|
};
|
|
|
|
let lastNonSettingsSection = "home";
|
|
|
|
function getElements() {
|
|
return {
|
|
openSettingsEl: document.getElementById("open-settings"),
|
|
closeSettingsEl: document.getElementById("close-settings"),
|
|
latEl: document.getElementById("lat"),
|
|
lngEl: document.getElementById("lng"),
|
|
timeFormatEl: document.getElementById("time-format"),
|
|
birthDateEl: document.getElementById("birth-date"),
|
|
tarotDeckEl: document.getElementById("tarot-deck"),
|
|
tarotDeckCacheStatusEl: document.getElementById("tarot-deck-cache-status"),
|
|
stellariumBackgroundEl: document.getElementById("stellarium-background"),
|
|
stellariumBackgroundHintEl: document.getElementById("stellarium-background-hint"),
|
|
apiBaseUrlEl: document.getElementById("api-base-url"),
|
|
apiKeyEl: document.getElementById("api-key"),
|
|
saveSettingsEl: document.getElementById("save-settings"),
|
|
useLocationEl: document.getElementById("use-location")
|
|
};
|
|
}
|
|
|
|
function setLocationEntryState(isExplicit) {
|
|
const { latEl, lngEl } = getElements();
|
|
const normalizedValue = isExplicit ? "true" : "false";
|
|
|
|
if (latEl) {
|
|
latEl.dataset.explicitLocation = normalizedValue;
|
|
}
|
|
|
|
if (lngEl) {
|
|
lngEl.dataset.explicitLocation = normalizedValue;
|
|
}
|
|
}
|
|
|
|
function hasExplicitLocationEntry() {
|
|
const { latEl } = getElements();
|
|
return latEl?.dataset.explicitLocation === "true";
|
|
}
|
|
|
|
function syncStellariumBackgroundAvailability() {
|
|
const { stellariumBackgroundEl, stellariumBackgroundHintEl } = getElements();
|
|
if (!stellariumBackgroundEl) {
|
|
return;
|
|
}
|
|
|
|
const hasExplicitLocation = hasExplicitLocationEntry();
|
|
stellariumBackgroundEl.disabled = !hasExplicitLocation;
|
|
|
|
if (!hasExplicitLocation) {
|
|
stellariumBackgroundEl.checked = false;
|
|
}
|
|
|
|
if (stellariumBackgroundHintEl) {
|
|
stellariumBackgroundHintEl.textContent = hasExplicitLocation
|
|
? "Uses your saved location to load the live sky background."
|
|
: "Enter a location or use My Location before enabling the live sky background.";
|
|
}
|
|
}
|
|
|
|
function markLocationAsExplicit() {
|
|
setLocationEntryState(true);
|
|
syncStellariumBackgroundAvailability();
|
|
}
|
|
function getConnectionSettings() {
|
|
return window.TarotAppConfig?.getConnectionSettings?.() || {
|
|
apiBaseUrl: String(window.TarotAppConfig?.apiBaseUrl || "").trim(),
|
|
apiKey: String(window.TarotAppConfig?.apiKey || "").trim()
|
|
};
|
|
}
|
|
|
|
function syncConnectionInputs() {
|
|
const { apiBaseUrlEl, apiKeyEl } = getElements();
|
|
const connectionSettings = getConnectionSettings();
|
|
|
|
if (apiBaseUrlEl) {
|
|
apiBaseUrlEl.value = String(connectionSettings.apiBaseUrl || "");
|
|
}
|
|
|
|
if (apiKeyEl) {
|
|
apiKeyEl.value = String(connectionSettings.apiKey || "");
|
|
}
|
|
}
|
|
|
|
function hasConnectionChanged(previous, next) {
|
|
return String(previous?.apiBaseUrl || "").trim() !== String(next?.apiBaseUrl || "").trim()
|
|
|| String(previous?.apiKey || "").trim() !== String(next?.apiKey || "").trim();
|
|
}
|
|
|
|
|
|
function setStatus(text) {
|
|
if (typeof config.onStatus === "function") {
|
|
config.onStatus(text);
|
|
}
|
|
}
|
|
|
|
function applyExternalSettings(settings) {
|
|
if (typeof config.onSettingsApplied === "function") {
|
|
config.onSettingsApplied(settings);
|
|
}
|
|
}
|
|
|
|
function formatDeckCacheStatus(status) {
|
|
const activeDeckId = String(status?.activeDeckId || normalizeTarotDeck(getElements().tarotDeckEl?.value)).trim().toLowerCase();
|
|
const totalDeckCount = Number(status?.totalDeckCount) || 0;
|
|
const warmedDeckCount = Number(status?.warmedDeckCount) || 0;
|
|
const warmedAllDecks = totalDeckCount > 0 && warmedDeckCount >= totalDeckCount;
|
|
|
|
if (status?.selectedDeckPhase === "loading") {
|
|
return "Caching selected deck images to this browser...";
|
|
}
|
|
|
|
if (status?.selectedDeckPhase === "error") {
|
|
return "Selected deck cache warmup hit an error. Images will still load on demand.";
|
|
}
|
|
|
|
if (status?.backgroundPhase === "loading") {
|
|
if (warmedDeckCount > 0 && totalDeckCount > 0) {
|
|
return `Selected deck cached. Warming remaining decks in background (${warmedDeckCount}/${totalDeckCount}).`;
|
|
}
|
|
return "Selected deck cached. Warming remaining decks in background...";
|
|
}
|
|
|
|
if (status?.backgroundPhase === "error") {
|
|
return "Selected deck cached. Background warmup for other decks stopped early.";
|
|
}
|
|
|
|
if (status?.selectedDeckPhase === "ready" || warmedAllDecks) {
|
|
if (warmedAllDecks) {
|
|
return "Selected deck cached. All available decks are warmed in this browser.";
|
|
}
|
|
return `Selected deck cached and ready for fullscreen use (${activeDeckId}).`;
|
|
}
|
|
|
|
return "Deck cache idle.";
|
|
}
|
|
|
|
function syncDeckCacheStatus(status) {
|
|
const { tarotDeckCacheStatusEl } = getElements();
|
|
if (!tarotDeckCacheStatusEl) {
|
|
return;
|
|
}
|
|
|
|
tarotDeckCacheStatusEl.textContent = formatDeckCacheStatus(status);
|
|
}
|
|
|
|
function syncSky(geo, options) {
|
|
if (typeof config.onSyncSkyBackground === "function") {
|
|
config.onSyncSkyBackground(geo, options);
|
|
}
|
|
}
|
|
|
|
function normalizeTimeFormat(value) {
|
|
if (value === "hours") {
|
|
return "hours";
|
|
}
|
|
|
|
if (value === "seconds") {
|
|
return "seconds";
|
|
}
|
|
|
|
return "minutes";
|
|
}
|
|
|
|
function normalizeBirthDate(value) {
|
|
const normalized = String(value || "").trim();
|
|
if (!normalized) {
|
|
return "";
|
|
}
|
|
|
|
return /^\d{4}-\d{2}-\d{2}$/.test(normalized) ? normalized : "";
|
|
}
|
|
|
|
function getKnownTarotDeckIds() {
|
|
const knownDeckIds = new Set();
|
|
const deckOptions = window.TarotCardImages?.getDeckOptions?.();
|
|
|
|
if (Array.isArray(deckOptions)) {
|
|
deckOptions.forEach((option) => {
|
|
const id = String(option?.id || "").trim().toLowerCase();
|
|
if (id) {
|
|
knownDeckIds.add(id);
|
|
}
|
|
});
|
|
}
|
|
|
|
if (!knownDeckIds.size) {
|
|
knownDeckIds.add(String(config.defaultSettings?.tarotDeck || "ceremonial-magick").trim().toLowerCase());
|
|
}
|
|
|
|
return knownDeckIds;
|
|
}
|
|
|
|
function getFallbackTarotDeckId() {
|
|
const deckOptions = window.TarotCardImages?.getDeckOptions?.();
|
|
if (Array.isArray(deckOptions)) {
|
|
for (let i = 0; i < deckOptions.length; i += 1) {
|
|
const id = String(deckOptions[i]?.id || "").trim().toLowerCase();
|
|
if (id) {
|
|
return id;
|
|
}
|
|
}
|
|
}
|
|
|
|
return String(config.defaultSettings?.tarotDeck || "ceremonial-magick").trim().toLowerCase();
|
|
}
|
|
|
|
function normalizeTarotDeck(value) {
|
|
const normalized = String(value || "").trim().toLowerCase();
|
|
const knownDeckIds = getKnownTarotDeckIds();
|
|
|
|
if (knownDeckIds.has(normalized)) {
|
|
return normalized;
|
|
}
|
|
|
|
return getFallbackTarotDeckId();
|
|
}
|
|
|
|
function parseStoredNumber(value, fallback) {
|
|
const parsed = Number(value);
|
|
return Number.isFinite(parsed) ? parsed : fallback;
|
|
}
|
|
|
|
function parseStoredBoolean(value, fallback = false) {
|
|
return typeof value === "boolean" ? value : fallback;
|
|
}
|
|
|
|
function hasLegacyExplicitLocation(settings, normalizedLatitude, normalizedLongitude) {
|
|
const hasStoredCoordinates = Number.isFinite(Number(settings?.latitude)) && Number.isFinite(Number(settings?.longitude));
|
|
if (!hasStoredCoordinates) {
|
|
return false;
|
|
}
|
|
|
|
return Math.abs(normalizedLatitude - Number(config.defaultSettings.latitude)) > 0.00005
|
|
|| Math.abs(normalizedLongitude - Number(config.defaultSettings.longitude)) > 0.00005;
|
|
}
|
|
|
|
function normalizeSettings(settings) {
|
|
const latitude = parseStoredNumber(settings?.latitude, config.defaultSettings.latitude);
|
|
const longitude = parseStoredNumber(settings?.longitude, config.defaultSettings.longitude);
|
|
const hasExplicitLocation = typeof settings?.hasExplicitLocation === "boolean"
|
|
? settings.hasExplicitLocation
|
|
: hasLegacyExplicitLocation(settings, latitude, longitude);
|
|
|
|
return {
|
|
latitude,
|
|
longitude,
|
|
timeFormat: normalizeTimeFormat(settings?.timeFormat),
|
|
birthDate: normalizeBirthDate(settings?.birthDate),
|
|
tarotDeck: normalizeTarotDeck(settings?.tarotDeck),
|
|
stellariumBackgroundEnabled: parseStoredBoolean(settings?.stellariumBackgroundEnabled, false) && hasExplicitLocation,
|
|
hasExplicitLocation
|
|
};
|
|
}
|
|
|
|
function getResolvedTimeZone() {
|
|
try {
|
|
const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
|
|
return String(timeZone || "");
|
|
} catch {
|
|
return "";
|
|
}
|
|
}
|
|
|
|
function buildBirthDateParts(birthDate) {
|
|
const normalized = normalizeBirthDate(birthDate);
|
|
if (!normalized) {
|
|
return null;
|
|
}
|
|
|
|
const [year, month, day] = normalized.split("-").map((value) => Number(value));
|
|
if (!year || !month || !day) {
|
|
return null;
|
|
}
|
|
|
|
const localNoon = new Date(year, month - 1, day, 12, 0, 0, 0);
|
|
const utcNoon = new Date(Date.UTC(year, month - 1, day, 12, 0, 0, 0));
|
|
|
|
return {
|
|
year,
|
|
month,
|
|
day,
|
|
isoDate: normalized,
|
|
localNoonIso: localNoon.toISOString(),
|
|
utcNoonIso: utcNoon.toISOString(),
|
|
timezoneOffsetMinutesAtNoon: localNoon.getTimezoneOffset()
|
|
};
|
|
}
|
|
|
|
function buildNatalContext(settings) {
|
|
const normalized = normalizeSettings(settings);
|
|
const birthDateParts = buildBirthDateParts(normalized.birthDate);
|
|
const timeZone = getResolvedTimeZone();
|
|
|
|
return {
|
|
latitude: normalized.latitude,
|
|
longitude: normalized.longitude,
|
|
birthDate: normalized.birthDate || null,
|
|
birthDateParts,
|
|
timeZone: timeZone || "UTC",
|
|
timezoneOffsetMinutesNow: new Date().getTimezoneOffset(),
|
|
timezoneOffsetMinutesAtBirthDateNoon: birthDateParts?.timezoneOffsetMinutesAtNoon ?? null
|
|
};
|
|
}
|
|
|
|
function emitSettingsUpdated(settings) {
|
|
const normalized = normalizeSettings(settings);
|
|
const natalContext = buildNatalContext(normalized);
|
|
document.dispatchEvent(new CustomEvent("settings:updated", {
|
|
detail: {
|
|
settings: normalized,
|
|
natalContext
|
|
}
|
|
}));
|
|
}
|
|
|
|
function loadSavedSettings() {
|
|
try {
|
|
const raw = window.localStorage.getItem(SETTINGS_STORAGE_KEY);
|
|
if (!raw) {
|
|
return { ...config.defaultSettings };
|
|
}
|
|
|
|
const parsed = JSON.parse(raw);
|
|
return normalizeSettings(parsed);
|
|
} catch {
|
|
return { ...config.defaultSettings };
|
|
}
|
|
}
|
|
|
|
function saveSettings(settings) {
|
|
try {
|
|
const normalized = normalizeSettings(settings);
|
|
window.localStorage.setItem(SETTINGS_STORAGE_KEY, JSON.stringify(normalized));
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function syncTarotDeckInputOptions() {
|
|
const { tarotDeckEl } = getElements();
|
|
if (!tarotDeckEl) {
|
|
return;
|
|
}
|
|
|
|
const deckOptions = window.TarotCardImages?.getDeckOptions?.();
|
|
const previousValue = String(tarotDeckEl.value || "").trim().toLowerCase();
|
|
tarotDeckEl.innerHTML = "";
|
|
|
|
if (!Array.isArray(deckOptions) || !deckOptions.length) {
|
|
const emptyOption = document.createElement("option");
|
|
emptyOption.value = String(config.defaultSettings?.tarotDeck || "ceremonial-magick").trim().toLowerCase();
|
|
emptyOption.textContent = "No deck manifests found";
|
|
tarotDeckEl.appendChild(emptyOption);
|
|
tarotDeckEl.disabled = true;
|
|
return;
|
|
}
|
|
|
|
tarotDeckEl.disabled = false;
|
|
|
|
deckOptions.forEach((option) => {
|
|
const id = String(option?.id || "").trim().toLowerCase();
|
|
if (!id) {
|
|
return;
|
|
}
|
|
|
|
const label = String(option?.label || id);
|
|
const optionEl = document.createElement("option");
|
|
optionEl.value = id;
|
|
optionEl.textContent = label;
|
|
tarotDeckEl.appendChild(optionEl);
|
|
});
|
|
|
|
tarotDeckEl.value = normalizeTarotDeck(previousValue);
|
|
}
|
|
|
|
function applySettingsToInputs(settings) {
|
|
const { latEl, lngEl, timeFormatEl, birthDateEl, tarotDeckEl, stellariumBackgroundEl } = getElements();
|
|
syncTarotDeckInputOptions();
|
|
syncConnectionInputs();
|
|
const normalized = normalizeSettings(settings);
|
|
latEl.value = String(normalized.latitude);
|
|
lngEl.value = String(normalized.longitude);
|
|
timeFormatEl.value = normalized.timeFormat;
|
|
birthDateEl.value = normalized.birthDate;
|
|
if (tarotDeckEl) {
|
|
tarotDeckEl.value = normalized.tarotDeck;
|
|
}
|
|
setLocationEntryState(normalized.hasExplicitLocation);
|
|
if (stellariumBackgroundEl) {
|
|
stellariumBackgroundEl.checked = normalized.stellariumBackgroundEnabled;
|
|
}
|
|
syncStellariumBackgroundAvailability();
|
|
if (window.TarotCardImages?.setActiveDeck) {
|
|
window.TarotCardImages.setActiveDeck(normalized.tarotDeck);
|
|
}
|
|
syncDeckCacheStatus(window.TarotCardImages?.getDeckPreloadStatus?.());
|
|
applyExternalSettings(normalized);
|
|
return normalized;
|
|
}
|
|
|
|
function getSettingsFromInputs() {
|
|
const { latEl, lngEl, timeFormatEl, birthDateEl, tarotDeckEl, stellariumBackgroundEl } = getElements();
|
|
const latitudeText = String(latEl?.value || "").trim();
|
|
const longitudeText = String(lngEl?.value || "").trim();
|
|
|
|
if (!latitudeText || !longitudeText) {
|
|
throw new Error("Latitude/Longitude must be entered before saving settings.");
|
|
}
|
|
|
|
const latitude = Number(latitudeText);
|
|
const longitude = Number(longitudeText);
|
|
|
|
if (Number.isNaN(latitude) || Number.isNaN(longitude)) {
|
|
throw new Error("Latitude/Longitude must be valid numbers.");
|
|
}
|
|
|
|
return normalizeSettings({
|
|
latitude,
|
|
longitude,
|
|
timeFormat: normalizeTimeFormat(timeFormatEl.value),
|
|
birthDate: normalizeBirthDate(birthDateEl.value),
|
|
tarotDeck: normalizeTarotDeck(tarotDeckEl?.value),
|
|
stellariumBackgroundEnabled: Boolean(stellariumBackgroundEl?.checked),
|
|
hasExplicitLocation: hasExplicitLocationEntry()
|
|
});
|
|
}
|
|
|
|
function getConnectionSettingsFromInputs() {
|
|
const { apiBaseUrlEl, apiKeyEl } = getElements();
|
|
|
|
return {
|
|
apiBaseUrl: String(apiBaseUrlEl?.value || "").trim(),
|
|
apiKey: String(apiKeyEl?.value || "").trim()
|
|
};
|
|
}
|
|
|
|
function openSettingsPopup() {
|
|
const activeSection = typeof config.getActiveSection === "function" ? config.getActiveSection() : "home";
|
|
if (activeSection && activeSection !== "settings") {
|
|
lastNonSettingsSection = activeSection;
|
|
}
|
|
applySettingsToInputs(loadSavedSettings());
|
|
config.setActiveSection?.("settings");
|
|
}
|
|
|
|
function closeSettingsPopup() {
|
|
config.setActiveSection?.(lastNonSettingsSection || "home");
|
|
}
|
|
|
|
async function handleSaveSettings() {
|
|
try {
|
|
const settings = getSettingsFromInputs();
|
|
const previousConnectionSettings = getConnectionSettings();
|
|
const connectionSettings = getConnectionSettingsFromInputs();
|
|
const connectionChanged = hasConnectionChanged(previousConnectionSettings, connectionSettings);
|
|
const connectionResult = window.TarotAppConfig?.updateConnectionSettings?.(connectionSettings) || { didPersist: true };
|
|
const normalized = applySettingsToInputs(settings);
|
|
syncSky(
|
|
{ latitude: normalized.latitude, longitude: normalized.longitude },
|
|
{
|
|
force: true,
|
|
backgroundEnabled: normalized.stellariumBackgroundEnabled,
|
|
hasExplicitLocation: normalized.hasExplicitLocation
|
|
}
|
|
);
|
|
const didPersist = saveSettings(normalized);
|
|
emitSettingsUpdated(normalized);
|
|
if (typeof config.getActiveSection === "function" && config.getActiveSection() !== "home" && config.getActiveSection() !== "settings") {
|
|
config.onReopenActiveSection?.(config.getActiveSection());
|
|
}
|
|
if (connectionChanged && typeof config.onConnectionSaved === "function") {
|
|
await config.onConnectionSaved(connectionResult, connectionSettings);
|
|
} else if (typeof config.onRenderWeek === "function") {
|
|
await config.onRenderWeek();
|
|
}
|
|
|
|
if (!didPersist || connectionResult.didPersist === false) {
|
|
setStatus("Settings applied for this session. Browser storage is unavailable.");
|
|
} else {
|
|
setStatus("Settings saved.");
|
|
}
|
|
} catch (error) {
|
|
setStatus(error?.message || "Unable to save settings.");
|
|
}
|
|
}
|
|
|
|
function requestGeoLocation() {
|
|
const { latEl, lngEl } = getElements();
|
|
if (!navigator.geolocation) {
|
|
setStatus("Geolocation not available in this browser.");
|
|
return;
|
|
}
|
|
|
|
setStatus("Getting your location...");
|
|
navigator.geolocation.getCurrentPosition(
|
|
({ coords }) => {
|
|
latEl.value = coords.latitude.toFixed(4);
|
|
lngEl.value = coords.longitude.toFixed(4);
|
|
markLocationAsExplicit();
|
|
syncSky(
|
|
{ latitude: coords.latitude, longitude: coords.longitude },
|
|
{
|
|
force: true,
|
|
backgroundEnabled: Boolean(getElements().stellariumBackgroundEl?.checked),
|
|
hasExplicitLocation: true
|
|
}
|
|
);
|
|
setStatus("Location set from browser. Save Settings to use it across the app.");
|
|
},
|
|
(err) => {
|
|
const detail = err?.message || `code ${err?.code ?? "unknown"}`;
|
|
setStatus(`Could not get location (${detail}).`);
|
|
},
|
|
{ enableHighAccuracy: true, timeout: 10000 }
|
|
);
|
|
}
|
|
|
|
function bindInteractions() {
|
|
const {
|
|
saveSettingsEl,
|
|
useLocationEl,
|
|
openSettingsEl,
|
|
closeSettingsEl,
|
|
latEl,
|
|
lngEl
|
|
} = getElements();
|
|
|
|
if (saveSettingsEl) {
|
|
saveSettingsEl.addEventListener("click", () => {
|
|
void handleSaveSettings();
|
|
});
|
|
}
|
|
|
|
if (useLocationEl) {
|
|
useLocationEl.addEventListener("click", requestGeoLocation);
|
|
}
|
|
|
|
[latEl, lngEl].forEach((inputEl) => {
|
|
if (!inputEl) {
|
|
return;
|
|
}
|
|
|
|
inputEl.addEventListener("input", markLocationAsExplicit);
|
|
inputEl.addEventListener("change", markLocationAsExplicit);
|
|
});
|
|
|
|
if (openSettingsEl) {
|
|
openSettingsEl.addEventListener("click", (event) => {
|
|
event.stopPropagation();
|
|
if ((config.getActiveSection?.() || "home") !== "settings") {
|
|
openSettingsPopup();
|
|
} else {
|
|
closeSettingsPopup();
|
|
}
|
|
});
|
|
}
|
|
|
|
if (closeSettingsEl) {
|
|
closeSettingsEl.addEventListener("click", closeSettingsPopup);
|
|
}
|
|
|
|
document.addEventListener("keydown", (event) => {
|
|
if (event.key === "Escape" && (config.getActiveSection?.() || "home") === "settings") {
|
|
closeSettingsPopup();
|
|
}
|
|
});
|
|
|
|
document.addEventListener("connection:updated", () => {
|
|
syncConnectionInputs();
|
|
syncTarotDeckInputOptions();
|
|
syncDeckCacheStatus(window.TarotCardImages?.getDeckPreloadStatus?.());
|
|
});
|
|
|
|
document.addEventListener("tarot:deck-cache-status", (event) => {
|
|
syncDeckCacheStatus(event?.detail);
|
|
});
|
|
}
|
|
|
|
function init(nextConfig = {}) {
|
|
config = {
|
|
...config,
|
|
...nextConfig,
|
|
defaultSettings: {
|
|
...config.defaultSettings,
|
|
...(nextConfig.defaultSettings || {})
|
|
}
|
|
};
|
|
|
|
bindInteractions();
|
|
}
|
|
|
|
function loadInitialSettingsAndApply() {
|
|
const initialSettings = loadSavedSettings();
|
|
const normalized = applySettingsToInputs(initialSettings);
|
|
emitSettingsUpdated(normalized);
|
|
return normalized;
|
|
}
|
|
|
|
window.TarotSettingsUi = {
|
|
...(window.TarotSettingsUi || {}),
|
|
init,
|
|
openSettingsPopup,
|
|
closeSettingsPopup,
|
|
loadInitialSettingsAndApply,
|
|
buildNatalContext,
|
|
normalizeSettings
|
|
};
|
|
})();
|