// KefinTweaks Configuration UI
// Adds a configuration button to the Administration section in user preferences
// Opens configuration in a modal window
(function() {
'use strict';
console.log('[KefinTweaks Configuration] Initializing...');
const MODAL_ID = 'kefinTweaksConfigModal';
let currentLoadedConfig = null;
const DISCOVERY_SECTION_DEFINITIONS = [
{ key: 'spotlightGenre', label: 'Spotlight Sections (Genre)', defaultName: 'Spotlight' },
{ key: 'spotlightNetwork', label: 'Spotlight Sections (Network)', defaultName: 'Spotlight' },
{ key: 'genreMovies', label: 'Genre Movies', defaultName: '[Genre] Movies' },
{ key: 'studioShows', label: 'Shows from [Studio]', defaultName: 'Shows from [Studio]' },
{ key: 'collections', label: 'Collection Spotlight', defaultName: '[Collection Name]', extras: { minimumItems: 10 } },
{ key: 'becauseYouWatched', label: 'Because you watched [Movie]', defaultName: 'Because you watched [Movie]' },
{ key: 'becauseYouLiked', label: 'Because you liked [Movie]', defaultName: 'Because you liked [Movie]' },
{ key: 'starringTopActor', label: 'Starring [Top Actor]', defaultName: 'Starring [Actor]' },
{ key: 'directedByTopDirector', label: 'Directed by [Top Director]', defaultName: 'Directed by [Director]' },
{ key: 'writtenByTopWriter', label: 'Written by [Top Writer]', defaultName: 'Written by [Writer]' },
{ key: 'becauseYouRecentlyWatched', label: 'Because you recently watched [Movie]', defaultName: 'Because you recently watched [Movie]' },
{ key: 'starringActorRecentlyWatched', label: 'Starring [Actor] because you recently watched [Movie]', defaultName: 'Starring [Actor] because you recently watched [Movie]' },
{ key: 'directedByDirectorRecentlyWatched', label: 'Directed by [Director] because you recently watched [Movie]', defaultName: 'Directed by [Director] because you recently watched [Movie]' },
{ key: 'writtenByWriterRecentlyWatched', label: 'Written by [Writer] because you recently watched [Movie]', defaultName: 'Written by [Writer] because you recently watched [Movie]' }
];
// Check if user is admin
async function isAdmin() {
try {
if (window.ApiClient && window.ApiClient.getCurrentUser) {
const user = await window.ApiClient.getCurrentUser();
return user && user.Policy && user.Policy.IsAdministrator === true;
}
} catch (error) {
console.warn('[KefinTweaks Configuration] Could not check admin status:', error);
}
return false;
}
// Load default configuration from JS file
async function loadDefaultConfig() {
return new Promise((resolve, reject) => {
try {
const defaultConfigUrl = window.KefinTweaksConfig?.kefinTweaksRoot
? `${window.KefinTweaksConfig.kefinTweaksRoot}/kefinTweaks-default-config.js` : null;
if (!defaultConfigUrl) {
reject(new Error('No default config URL found'));
return;
}
// Check if already loaded
if (window.KefinTweaksDefaultConfig) {
console.log('[KefinTweaks Configuration] Using cached default config');
resolve(window.KefinTweaksDefaultConfig);
return;
}
// Create script element to load the JS file
const script = document.createElement('script');
script.src = defaultConfigUrl;
script.async = true;
script.onload = () => {
if (window.KefinTweaksDefaultConfig) {
console.log('[KefinTweaks Configuration] Loaded default config:', window.KefinTweaksDefaultConfig);
resolve(window.KefinTweaksDefaultConfig);
} else {
reject(new Error('Default config file loaded but window.KefinTweaksDefaultConfig is not defined'));
}
};
script.onerror = (error) => {
reject(new Error(`Failed to load default config file: ${defaultConfigUrl}`));
};
document.head.appendChild(script);
} catch (error) {
console.error('[KefinTweaks Configuration] Error loading default config:', error);
reject(error);
}
});
}
// Get KefinTweaks configuration from JS Injector or load defaults
async function getKefinTweaksConfig() {
try {
// First, try to get config from JS Injector
const pluginId = await findJavaScriptInjectorPlugin();
const injectorConfig = await getJavaScriptInjectorConfig(pluginId);
// Find KefinTweaks-Config script
const kefinTweaksScript = injectorConfig.CustomJavaScripts?.find(
script => script.Name === 'KefinTweaks-Config'
);
if (kefinTweaksScript && kefinTweaksScript.Script) {
// Extract config from script content
// The script should contain: window.KefinTweaksConfig = {...};
const scriptMatch = kefinTweaksScript.Script.match(/window\.KefinTweaksConfig\s*=\s*({[\s\S]*});/);
if (scriptMatch && scriptMatch[1]) {
try {
const config = JSON.parse(scriptMatch[1]);
// Store enabled state globally for use in modal (defaults to true if not set)
window.KefinTweaksConfigEnabled = config.enabled !== false;
console.log('[KefinTweaks Configuration] Loaded config from JS Injector:', config);
return config;
} catch (parseError) {
console.error('[KefinTweaks Configuration] Error parsing config from script:', parseError);
}
}
}
// If no config found in JS Injector, load defaults
console.log('[KefinTweaks Configuration] No config found in JS Injector, loading defaults');
const rawDefaultConfig = await loadDefaultConfig();
const defaultConfig = JSON.parse(JSON.stringify(rawDefaultConfig));
const currentConfigSource = currentLoadedConfig || window.KefinTweaksCurrentConfig || window.KefinTweaksConfig || {};
const currentKefinRoot = currentConfigSource.kefinTweaksRoot || defaultConfig.kefinTweaksRoot;
defaultConfig.kefinTweaksRoot = currentKefinRoot;
// Ensure enabled field is set (defaults to true if not present)
if (defaultConfig.enabled === undefined) {
defaultConfig.enabled = true;
}
// Store enabled state globally for use in modal
window.KefinTweaksConfigEnabled = defaultConfig.enabled !== false;
// Note: scriptRoot is no longer used - scripts are loaded from kefinTweaksRoot + '/scripts/'
// Save defaults to JS Injector for future use
await saveConfigToJavaScriptInjector(defaultConfig);
return defaultConfig;
} catch (error) {
console.error('[KefinTweaks Configuration] Error getting config, falling back to defaults:', error);
// Fallback to defaults if anything fails
try {
return await loadDefaultConfig();
} catch (fallbackError) {
console.error('[KefinTweaks Configuration] Error loading default config as fallback:', fallbackError);
// Return empty config structure as last resort
return {
kefinTweaksRoot: '',
scripts: {},
homeScreen: {},
exclusiveElsewhere: {},
search: {},
skins: [],
defaultSkin: null,
themes: [],
customMenuLinks: []
};
}
}
}
// Inject responsive CSS for the configuration modal
function injectConfigModalCSS() {
const styleId = 'kefintweaks-config-modal-css';
if (document.getElementById(styleId)) return;
const style = document.createElement('style');
style.id = styleId;
style.textContent = `
#${MODAL_ID} .modal-content-wrapper {
max-width: 90vw;
width: 1400px;
max-height: 90vh;
overflow-y: auto;
background: var(--background-color, #1a1a1a);
border-radius: 8px;
}
#${MODAL_ID} .content-primary {
max-width: 1400px;
margin: 0 auto;
padding: 1.5em;
}
#${MODAL_ID} .paperList {
background: rgba(255, 255, 255, 0.03);
border-radius: 8px;
padding: 1em;
}
#${MODAL_ID} .listItem {
transition: background-color 0.2s ease;
}
#${MODAL_ID} .listItem:hover {
background-color: rgba(255, 255, 255, 0.02);
}
#${MODAL_ID} textarea.fld {
resize: vertical;
min-height: 200px;
}
#${MODAL_ID} details summary {
user-select: none;
overflow: visible;
}
#${MODAL_ID} details summary:hover {
opacity: 0.8;
}
#${MODAL_ID} pre {
white-space: pre-wrap;
word-wrap: break-word;
}
/* Custom section collapsible styling */
#${MODAL_ID} .custom-section-summary {
position: relative;
list-style: none;
}
#${MODAL_ID} .custom-section-summary::-webkit-details-marker {
display: none;
}
#${MODAL_ID} .custom-section-summary::marker {
display: none;
}
#${MODAL_ID} details[open] .custom-section-summary .material-icons {
transform: rotate(90deg);
}
#${MODAL_ID} .custom-section-summary .material-icons {
transition: transform 0.2s ease;
}
/* Recently released subsection styling */
#${MODAL_ID} .recently-released-subsection-summary {
position: relative;
list-style: none;
}
#${MODAL_ID} .recently-released-subsection-summary::-webkit-details-marker {
display: none;
}
#${MODAL_ID} .recently-released-subsection-summary::marker {
display: none;
}
#${MODAL_ID} details[open] .recently-released-subsection-summary .material-icons {
transform: rotate(90deg);
}
#${MODAL_ID} .recently-released-subsection-summary .material-icons {
transition: transform 0.2s ease;
}
/* Seasonal season collapsible styling */
#${MODAL_ID} .seasonal-season-summary {
position: relative;
list-style: none;
}
#${MODAL_ID} .seasonal-season-summary::-webkit-details-marker {
display: none;
}
#${MODAL_ID} .seasonal-season-summary::marker {
display: none;
}
#${MODAL_ID} details[open] .seasonal-season-summary .material-icons {
transform: rotate(90deg);
}
#${MODAL_ID} .seasonal-season-summary .material-icons {
transition: transform 0.2s ease;
}
/* Seasonal section collapsible styling (sections within seasons) */
#${MODAL_ID} .seasonal-section-summary {
position: relative;
list-style: none;
}
#${MODAL_ID} .seasonal-section-summary::-webkit-details-marker {
display: none;
}
#${MODAL_ID} .seasonal-section-summary::marker {
display: none;
}
#${MODAL_ID} details[open] .seasonal-section-summary .material-icons {
transform: rotate(90deg);
}
#${MODAL_ID} .seasonal-section-summary .material-icons {
transition: transform 0.2s ease;
}
/* Discovery section type collapsible styling */
#${MODAL_ID} .discovery-section-type-summary {
position: relative;
list-style: none;
}
#${MODAL_ID} .discovery-section-type-summary::-webkit-details-marker {
display: none;
}
#${MODAL_ID} .discovery-section-type-summary::marker {
display: none;
}
#${MODAL_ID} details[open] .discovery-section-type-summary .material-icons {
transform: rotate(90deg);
}
#${MODAL_ID} .discovery-section-type-summary .material-icons {
transition: transform 0.2s ease;
}
/* Responsive design */
@media (max-width: 768px) {
#${MODAL_ID} .modal-content-wrapper {
width: 95vw;
max-height: 95vh;
}
#${MODAL_ID} .content-primary {
padding: 1em;
}
#${MODAL_ID} .paperList {
padding: 0.75em;
}
#${MODAL_ID} [style*="grid-template-columns"] {
grid-template-columns: 1fr !important;
}
}
@media (max-width: 480px) {
#${MODAL_ID} .content-primary {
padding: 0.75em;
}
#${MODAL_ID} .pageTitle {
font-size: 1.5em;
}
#${MODAL_ID} input.fld,
#${MODAL_ID} textarea.fld {
font-size: 16px; /* Prevents zoom on iOS */
}
}
`;
document.head.appendChild(style);
}
// Show confirmation modal for editing script root configuration
function showScriptRootEditConfirmation() {
return new Promise((resolve) => {
if (!window.ModalSystem) {
resolve(false);
return;
}
const modal = window.ModalSystem.create({
id: 'scriptRootEditConfirmation',
title: 'Edit KefinTweaks Root URL',
content: `
Editing the Root URL is useful if you are hosting the scripts yourself or if you want to use a specific KefinTweaks version. Scripts will be loaded from this root URL + '/scripts/'. There is no validation done for the URL provided so please ensure it is valid. In any case, you can easily revert this setting.
Configure default skin and available skins for all users
Default Skin
Select a default skin for all users
Enable/Disable Skins
Disabled skins will not appear in the appearance dropdowns for users
All themes are created with love by community members like you. Don't forget to thank them for their work and time if you appreciate their creations.
KefinTweaks has not contributed to the creation of any of the skins below and is only attempting to facilitate their accessibility.
${buildSkinToggles(skins)}
Skins JSON
Add additional skins that will be available to all users. Each skin can have multiple CSS files for different server versions. Hidden skins (included automatically by KefinTweaks) are not shown here.
`;
}).join('');
}
// Build script toggle switches
function buildScriptToggles(scripts) {
const scriptNames = [
{ key: 'watchlist', label: 'Watchlist', desc: 'Allows your users to add items to their Watchlist. The Watchlist page shows an overview of all items on a user\'s Watchlist, as well as their Series Progress and Movie History. It also includes a Statistics page with an overview of your user watched stats.' },
{ key: 'homeScreen', label: 'Enhanced Home Screen', desc: 'Add custom home screen sections and a "discovery engine" to your Home Page. Create sections based on Genre, Tags, Playlists, Collections or Search Terms for specific Item Types. Use the "Spotlight" feature to highlight specific sections with an image carousel/slideshow.' },
{ key: 'search', label: 'Enhanced Search', desc: 'Search speed is improved by searching less content types by default. Provides options to specify which content type to search. Fully compatible with both the Jellysearch Search from Jellyfin Enhanced plugin and the Meilisearch plugin.' },
{ key: 'infiniteScroll', label: 'Infinite Scroll', desc: 'Adds infinite scrolling to the library pages for Movies and TV' },
{ key: 'removeContinue', label: 'Remove Continue', desc: 'Adds the ability to remove items from the Continue Watching sections' },
{ key: 'skinManager', label: 'Skin Manager', desc: 'Skin selection and management - adds skin dropdown to header and display preferences' },
{ key: 'headerTabs', label: 'Header Tabs', desc: 'Allows direct navigation to specific Tab sections of a given library page. Full support for default Jellyfin landing pages.' },
{ key: 'customMenuLinks', label: 'Custom Menu Links', desc: 'Add custom menu links to the left side navigation menu' },
{ key: 'breadcrumbs', label: 'Breadcrumbs', desc: 'Breadcrumb navigation for Movies, TV and Music. Allows quick navigation between Seasons/Episodes and Albums/Songs.' },
{ key: 'playlist', label: 'Playlist UX', desc: 'Improved Playlist page navigation: Items only play when the Play button is pressed. Clicking an item navigates to the item\'s page.' },
{ key: 'itemDetailsCollections', label: 'Collections on Details Page', desc: 'Displays collections on item details pages (Included In section)' },
{ key: 'flattenSingleSeasonShows', label: 'Flatten Single Season Shows', desc: 'Flattens single-season shows to display episodes directly on series page' },
{ key: 'collections', label: 'Collection Sorting', desc: 'Collection sorting functionality on the Collection page' },
{ key: 'subtitleSearch', label: 'Subtitle Search', desc: 'Search and download subtitles directly from the video OSD' },
{ key: 'exclusiveElsewhere', label: 'Exclusive Elsewhere', desc: 'Custom branding when items aren\'t available on streaming services' },
{ key: 'backdropLeakFix', label: 'Backdrop Leak Fix', desc: 'Fixes memory leaks from backdrop images when tab isn\'t focused' },
{ key: 'dashboardButtonFix', label: 'Dashboard Button Fix', desc: 'Improved back button behavior on dashboard - prevents navigating back to the new tab browser page' }
];
return scriptNames.map(script => {
const isEnabled = scripts[script.key] !== false; // Default to true if not set
return `
Failed to load preview: ${error?.message || error}
`;
}
}
});
previewModal.open();
}
async function updateSectionSourceField(prefix, sectionIndex, isSeasonalNested) {
const sectionItem = modalInstance.dialogContent.querySelector(`.${prefix}_section_item[data-section-index="${sectionIndex}"]`);
if (!sectionItem) {
console.warn(`[KefinTweaks Configuration] Section item not found for prefix: ${prefix}, index: ${sectionIndex}`);
return;
}
const typeSelect = sectionItem.querySelector(`.${prefix}_section_type[data-section-index="${sectionIndex}"]`);
if (!typeSelect) {
console.warn(`[KefinTweaks Configuration] Type select not found for prefix: ${prefix}, index: ${sectionIndex}`);
return;
}
const type = typeSelect.value || 'Genre';
// Find the source field container using the specific class
const sourceContainer = sectionItem.querySelector(`.${prefix}_section_source_container[data-section-index="${sectionIndex}"]`);
if (!sourceContainer) {
console.warn(`[KefinTweaks Configuration] Source container not found for prefix: ${prefix}, index: ${sectionIndex}`);
return;
}
// Get current source value
const currentSourceInput = sectionItem.querySelector(`.${prefix}_section_source[data-section-index="${sectionIndex}"]`);
const badgeContainer = sourceContainer?.querySelector(`.tag-badge-container[data-section-index="${sectionIndex}"][data-type]`) || null;
let currentSource = '';
if (badgeContainer) {
// Extract from existing badges
const badges = badgeContainer.querySelectorAll('.tag-badge');
currentSource = Array.from(badges).map(badge => badge.getAttribute('data-value')).filter(Boolean).join(', ');
} else if (currentSourceInput) {
// Extract from dropdown/input
currentSource = currentSourceInput.value || '';
}
// Clear badges whenever the source type changes
// This ensures a clean state when switching between any types
const currentType = currentSourceInput?.dataset?.type || badgeContainer?.dataset?.type;
if (currentType && currentType !== type) {
currentSource = '';
}
let newSourceHtml = '';
if (type === 'Parent') {
// Parent type uses simple text input
newSourceHtml = `
Parent IDs (comma-separated, leave empty for "Any")
This will completely overwrite your current configuration. All existing settings will be replaced with the imported configuration. This action cannot be undone.
`,
footer: `
`,
closeOnBackdrop: true,
closeOnEscape: true,
onOpen: (modalInstance) => {
const confirmBtn = modalInstance.dialogFooter?.querySelector('#confirmImportConfirmBtn');
const cancelBtn = modalInstance.dialogFooter?.querySelector('#cancelImportConfirmBtn');
if (confirmBtn) {
confirmBtn.addEventListener('click', () => {
modalInstance.close();
resolve(true);
});
}
if (cancelBtn) {
cancelBtn.addEventListener('click', () => {
modalInstance.close();
resolve(false);
});
}
}
});
});
}
// Apply imported configuration
async function applyImportedConfig(importedConfig, modalInstance) {
// Save to JavaScript Injector
await saveConfigToJavaScriptInjector(importedConfig);
// Reload the modal with new config
modalInstance.close();
// Show success message
if (window.KefinTweaksToaster && window.KefinTweaksToaster.toast) {
window.KefinTweaksToaster.toast('Configuration imported successfully! Reloading...');
}
// Reopen modal with new config after a short delay
setTimeout(() => {
openConfigurationModal();
}, 500);
}
// Find JavaScript Injector plugin
async function findJavaScriptInjectorPlugin() {
try {
if (!window.ApiClient || !window.ApiClient._serverAddress || !window.ApiClient.accessToken) {
throw new Error('ApiClient not available');
}
const server = ApiClient._serverAddress;
const token = ApiClient.accessToken();
const response = await fetch(`${server}/Plugins`, {
headers: {
'X-Emby-Token': token
}
});
if (!response.ok) {
throw new Error(`HTTP ${response.status}: ${response.statusText}`);
}
const plugins = await response.json();
console.log('[KefinTweaks Configuration] Active Plugins:', plugins);
// Handle both array and object with Items property
const pluginsList = Array.isArray(plugins) ? plugins : (plugins.Items || []);
// Find JavaScript Injector plugin
const injectorPlugin = pluginsList.find(plugin =>
plugin.Name === 'JavaScript Injector' || plugin.Name === 'JS Injector'
);
if (!injectorPlugin) {
throw new Error('JavaScript Injector plugin not found. Please ensure it is installed.');
}
console.log('[KefinTweaks Configuration] Found JavaScript Injector plugin:', injectorPlugin);
return injectorPlugin.Id;
} catch (error) {
console.error('[KefinTweaks Configuration] Error finding JavaScript Injector plugin:', error);
throw error;
}
}
// Get current JavaScript Injector configuration
async function getJavaScriptInjectorConfig(pluginId) {
try {
if (!window.ApiClient || !window.ApiClient._serverAddress || !window.ApiClient.accessToken) {
throw new Error('ApiClient not available');
}
const server = ApiClient._serverAddress;
const token = ApiClient.accessToken();
const response = await fetch(`${server}/Plugins/${pluginId}/Configuration`, {
headers: {
'X-Emby-Token': token
}
});
if (!response.ok) {
throw new Error(`HTTP ${response.status}: ${response.statusText}`);
}
const config = await response.json();
console.log('[KefinTweaks Configuration] Current JS Injector config:', config);
return config;
} catch (error) {
console.error('[KefinTweaks Configuration] Error getting JS Injector config:', error);
throw error;
}
}
// Save configuration to JavaScript Injector plugin
async function saveConfigToJavaScriptInjector(config) {
try {
// Find the plugin
const pluginId = await findJavaScriptInjectorPlugin();
// Get fresh configuration data
const injectorConfig = await getJavaScriptInjectorConfig(pluginId);
// Ensure CustomJavaScripts array exists
if (!injectorConfig.CustomJavaScripts) {
injectorConfig.CustomJavaScripts = [];
}
// Create the script content
const scriptContent = `// KefinTweaks Configuration
// This file is automatically generated by KefinTweaks Configuration UI
// Do not edit manually unless you know what you're doing
window.KefinTweaksConfig = ${JSON.stringify(config, null, 2)};`;
// Check if KefinTweaks-Config already exists
const existingScriptIndex = injectorConfig.CustomJavaScripts.findIndex(
script => script.Name === 'KefinTweaks-Config'
);
if (existingScriptIndex !== -1) {
// Update existing script
console.log('[KefinTweaks Configuration] Updating existing KefinTweaks-Config script');
injectorConfig.CustomJavaScripts[existingScriptIndex].Script = scriptContent;
// Keep existing Enabled and RequiresAuthentication settings
} else {
// Add new script
console.log('[KefinTweaks Configuration] Adding new KefinTweaks-Config script');
injectorConfig.CustomJavaScripts.push({
Name: 'KefinTweaks-Config',
Script: scriptContent,
Enabled: true,
RequiresAuthentication: false
});
}
// POST the updated configuration back
const server = ApiClient._serverAddress;
const token = ApiClient.accessToken();
const response = await fetch(`${server}/Plugins/${pluginId}/Configuration`, {
method: 'POST',
headers: {
'X-Emby-Token': token,
'Content-Type': 'application/json'
},
body: JSON.stringify(injectorConfig)
});
if (!response.ok) {
throw new Error(`HTTP ${response.status}: ${response.statusText}`);
}
console.log('[KefinTweaks Configuration] Configuration saved successfully');
return true;
} catch (error) {
console.error('[KefinTweaks Configuration] Error saving configuration:', error);
throw error;
}
}
function getSectionConfigFromUI(rootElement, prefix, sectionIndex) {
const scope = rootElement || document;
const sectionItem = scope.querySelector(`.${prefix}_section_item[data-section-index="${sectionIndex}"]`);
if (!sectionItem) return null;
const sanitizedIndex = sectionIndex.toString().replace(/[^a-zA-Z0-9]/g, '_');
const sectionIdAttr = sectionItem.getAttribute('data-section-id') || `${prefix}-section-${sanitizedIndex}`;
const enabledCheckbox = sectionItem.querySelector(`#${prefix}_section_enabled_${sanitizedIndex}`) || sectionItem.querySelector(`.${prefix}_section_enabled[data-section-index="${sectionIndex}"]`);
const enabled = enabledCheckbox?.checked !== false;
const name = sectionItem.querySelector(`.${prefix}_section_name[data-section-index="${sectionIndex}"]`)?.value || '';
const type = sectionItem.querySelector(`.${prefix}_section_type[data-section-index="${sectionIndex}"]`)?.value || 'Genre';
let source = '';
const sourceContainer = sectionItem.querySelector(`.${prefix}_section_source_container[data-section-index="${sectionIndex}"]`);
const badgeContainer = sourceContainer?.querySelector(`.tag-badge-container[data-section-index="${sectionIndex}"][data-type]`) || null;
if (badgeContainer) {
const badges = badgeContainer.querySelectorAll('.tag-badge');
source = Array.from(badges).map(badge => badge.getAttribute('data-value')).filter(Boolean).join(', ');
} else {
const sourceInput = sectionItem.querySelector(`.${prefix}_section_source[data-section-index="${sectionIndex}"]`);
source = sourceInput ? sourceInput.value : '';
}
const itemLimit = parseInt(sectionItem.querySelector(`#${prefix}_section_${sanitizedIndex}_itemLimit`)?.value || '16', 10);
const sortOrder = sectionItem.querySelector(`#${prefix}_section_${sanitizedIndex}_sortOrder`)?.value || 'Random';
const sortOrderDirection = sectionItem.querySelector(`#${prefix}_section_${sanitizedIndex}_sortOrderDirection`)?.value || 'Ascending';
const cardFormat = sectionItem.querySelector(`#${prefix}_section_${sanitizedIndex}_cardFormat`)?.value || 'Poster';
const order = parseInt(sectionItem.querySelector(`#${prefix}_section_${sanitizedIndex}_order`)?.value || '100', 10);
const spotlightCheckbox = sectionItem.querySelector(`#${prefix}_section_${sanitizedIndex}_spotlight`) || sectionItem.querySelector(`.${prefix}_section_spotlight[data-section-index="${sectionIndex}"]`);
const discoveryCheckbox = sectionItem.querySelector(`#${prefix}_section_${sanitizedIndex}_discovery`) || sectionItem.querySelector(`.${prefix}_section_discovery[data-section-index="${sectionIndex}"]`);
const spotlight = spotlightCheckbox?.checked === true;
const discoveryEnabled = discoveryCheckbox?.checked === true;
const searchTerm = sectionItem.querySelector(`#${prefix}_section_${sanitizedIndex}_searchTerm`)?.value?.trim() || '';
let includeItemTypes = [];
const includeItemTypesContainer = sectionItem.querySelector(`.includeItemTypes-badge-container[data-section-index="${sectionIndex}"]`);
if (includeItemTypesContainer) {
const badges = includeItemTypesContainer.querySelectorAll('.tag-badge');
includeItemTypes = Array.from(badges).map(badge => badge.getAttribute('data-value')).filter(Boolean);
}
if (includeItemTypes.length === 0 && type !== 'Parent') {
includeItemTypes = ['Movie'];
}
return {
id: sectionIdAttr,
enabled: enabled,
name: name,
type: type,
source: source,
itemLimit: itemLimit,
sortOrder: sortOrder,
sortOrderDirection: sortOrderDirection,
cardFormat: cardFormat,
order: order,
spotlight: spotlight,
discoveryEnabled: discoveryEnabled,
searchTerm: searchTerm,
includeItemTypes: includeItemTypes
};
}
async function fetchItemsForSectionPreview(sectionConfig) {
const apiClient = window.ApiClient;
if (!apiClient) {
throw new Error('ApiClient is not available');
}
const userId = apiClient.getCurrentUserId();
const serverAddress = apiClient.serverAddress();
const token = apiClient.accessToken();
const type = sectionConfig.type || 'Genre';
const searchTerm = sectionConfig.searchTerm?.trim() || '';
const includeItemTypes = Array.isArray(sectionConfig.includeItemTypes) && sectionConfig.includeItemTypes.length > 0
? sectionConfig.includeItemTypes.join(',')
: (sectionConfig.includeItemTypes || 'Movie');
const sortOrder = sectionConfig.sortOrder || 'Random';
const sortOrderDirection = sectionConfig.sortOrderDirection || 'Ascending';
const itemLimit = parseInt(sectionConfig.itemLimit, 10) || 16;
const sources = (sectionConfig.source || '').split(',').map(s => s.trim()).filter(Boolean);
const fields = 'PrimaryImageAspectRatio,DateCreated,Overview,ProductionYear,ImageTags,BackdropImageTags,ParentBackdropImageTags,ParentThumbImageTag,SeriesPrimaryImageTag';
const headers = { 'Authorization': `MediaBrowser Token="${token}"` };
const dedupeAndLimit = (items = []) => {
let working = Array.isArray(items) ? [...items] : [];
if (sortOrder === 'Random') {
working.sort(() => Math.random() - 0.5);
} else if (window.cardBuilder?.sortItems) {
working = window.cardBuilder.sortItems(working, sortOrder, sortOrderDirection);
}
const seen = new Set();
const limited = [];
for (const item of working) {
if (!item || !item.Id || seen.has(item.Id)) continue;
seen.add(item.Id);
limited.push(item);
if (limited.length >= itemLimit) break;
}
return limited;
};
const fetchJson = async (url) => {
const response = await fetch(url, { headers });
if (!response.ok) {
throw new Error(`HTTP ${response.status}`);
}
return response.json();
};
try {
if (type === 'Genre' || type === 'Tag') {
if (sources.length === 0) {
return [];
}
const paramName = type === 'Genre' ? 'Genres' : 'Tags';
const valueParam = sources.map(s => encodeURIComponent(s)).join('|');
const url = `${serverAddress}/Items?userId=${userId}&${paramName}=${valueParam}` +
`&IncludeItemTypes=${encodeURIComponent(includeItemTypes)}` +
`&Recursive=true&Fields=${encodeURIComponent(fields)}` +
`&Limit=${itemLimit}&SortBy=${encodeURIComponent(sortOrder)}&SortOrder=${encodeURIComponent(sortOrderDirection)}` +
(searchTerm ? `&SearchTerm=${encodeURIComponent(searchTerm)}` : '');
const data = await fetchJson(url);
return dedupeAndLimit(data.Items || []);
}
if (type === 'Collection' || type === 'Playlist' || type === 'Parent') {
const existingIds = new Set();
let collected = [];
const queryBase = {
IncludeItemTypes: includeItemTypes,
Recursive: true,
Fields: fields,
SortBy: sortOrder,
SortOrder: sortOrderDirection
};
const runQuery = async (params) => {
const response = await apiClient.getItems(userId, params);
if (response?.Items?.length) {
response.Items.forEach(item => {
if (item && item.Id && !existingIds.has(item.Id)) {
existingIds.add(item.Id);
collected.push(item);
}
});
}
};
if (type === 'Parent' && sources.length === 0) {
const params = {
...queryBase,
Limit: itemLimit * 2
};
if (searchTerm) params.SearchTerm = searchTerm;
await runQuery(params);
} else {
const multiplier = Math.max(1, sources.length);
for (const parentId of sources) {
const params = {
...queryBase,
ParentId: parentId,
Limit: itemLimit * multiplier
};
if (searchTerm) params.SearchTerm = searchTerm;
await runQuery(params);
}
}
return dedupeAndLimit(collected);
}
return [];
} catch (error) {
console.warn('[KefinTweaks Configuration] Preview fetch failed:', error);
throw error;
}
}
// Handle save configuration
async function handleSaveConfig(modalInstance) {
// Verify admin status before saving
const userIsAdmin = await isAdmin();
if (!userIsAdmin) {
alert('You must be an administrator to save configuration.');
return;
}
console.log('[KefinTweaks Configuration] Saving configuration...');
// Collect all form values
const config = {
kefinTweaksRoot: document.getElementById('kefinTweaksRoot')?.value || '',
scripts: {},
homeScreen: {},
exclusiveElsewhere: {},
search: {},
defaultSkin: document.getElementById('defaultSkin')?.value || null,
skins: [],
themes: [],
customMenuLinks: []
};
config.enabled = modalInstance.dialogContent.querySelector('#kefinTweaksEnabled')?.checked !== false;
// Remove scriptRoot if it exists (legacy field, no longer used)
if (config.scriptRoot) {
delete config.scriptRoot;
}
// Collect script toggles
document.querySelectorAll('[data-script-key]').forEach(checkbox => {
const key = checkbox.getAttribute('data-script-key');
config.scripts[key] = checkbox.checked;
});
// Helper function to get section config
function getSectionConfig(prefix, includeSortOrderOrOptions = true, includeOrderFlag = true) {
let includeSortOrder = true;
let includeOrder = true;
let includeName = false;
let defaultName = '';
if (typeof includeSortOrderOrOptions === 'object') {
const opts = includeSortOrderOrOptions || {};
includeSortOrder = opts.includeSortOrder !== undefined ? opts.includeSortOrder : true;
includeOrder = opts.includeOrder !== undefined ? opts.includeOrder : true;
includeName = opts.includeName === true;
defaultName = opts.defaultName || '';
} else {
includeSortOrder = includeSortOrderOrOptions !== false;
includeOrder = includeOrderFlag !== false;
}
const config = {
itemLimit: parseInt(document.getElementById(`${prefix}_itemLimit`)?.value || '16', 10)
};
if (includeName) {
config.name = document.getElementById(`${prefix}_name`)?.value || defaultName || '';
}
if (includeSortOrder) {
config.sortOrder = document.getElementById(`${prefix}_sortOrder`)?.value || 'Random';
config.sortOrderDirection = document.getElementById(`${prefix}_sortOrderDirection`)?.value || 'Ascending';
}
config.cardFormat = document.getElementById(`${prefix}_cardFormat`)?.value || 'Poster';
if (includeOrder) {
config.order = parseInt(document.getElementById(`${prefix}_order`)?.value || '100', 10);
}
return config;
}
// Collect seasonal seasons
function getSeasonalSeasons() {
const seasons = [];
const seasonItems = modalInstance.dialogContent.querySelectorAll('.seasonal-season-item');
seasonItems.forEach((item, seasonIndex) => {
// Try to find checkbox by ID first, then fall back to class selector
const enabledCheckbox = item.querySelector(`#seasonal-season-enabled-${seasonIndex}`) || item.querySelector('.seasonal-season-enabled[data-index="${seasonIndex}"]');
const enabled = enabledCheckbox?.checked !== false;
const name = item.querySelector('.seasonal-season-name')?.value || '';
const startDate = item.querySelector('.seasonal-season-startDate')?.value || '';
const endDate = item.querySelector('.seasonal-season-endDate')?.value || '';
const orderInput = item.querySelector(`.seasonal-season-order-input[data-index="${seasonIndex}"]`);
const order = orderInput ? parseInt(orderInput.value || '100', 10) : 100;
// Collect nested sections
const sectionsList = item.querySelector(`.seasonal_season_sections_list[data-season-index="${seasonIndex}"]`);
const sections = [];
if (sectionsList) {
const sectionItems = sectionsList.querySelectorAll('.seasonal_season_section_item');
sectionItems.forEach((sectionItem, sectionItemIndex) => {
const fullIndex = `${seasonIndex}_${sectionItemIndex}`;
const sectionConfig = getSectionConfigFromUI(modalInstance.dialogContent, 'seasonal_season', fullIndex);
if (sectionConfig) {
sections.push(sectionConfig);
}
});
}
const seasonConfig = {
id: name.toLowerCase().replace(/\s+/g, '-') || `season-${seasonIndex}`,
name: name,
enabled: enabled,
startDate: startDate,
endDate: endDate,
order: order,
sections: sections
};
seasons.push(seasonConfig);
});
return seasons;
}
// Collect custom sections
function getCustomSections() {
const sectionsList = modalInstance.dialogContent.querySelector('#customSections_list');
const sections = [];
if (!sectionsList) {
return sections;
}
const sectionItems = sectionsList.querySelectorAll('.customSection_section_item');
sectionItems.forEach((sectionItem, index) => {
const sectionIndex = sectionItem.getAttribute('data-section-index') ?? index;
const sectionConfig = getSectionConfigFromUI(modalInstance.dialogContent, 'customSection', sectionIndex);
if (sectionConfig) {
sections.push(sectionConfig);
}
});
return sections;
}
// Collect home screen config
config.homeScreen = {
defaultItemLimit: 16,
defaultSortOrder: 'Random',
defaultCardFormat: 'Poster',
recentlyReleased: {
enabled: document.getElementById('homeScreen_recentlyReleased_enabled')?.checked !== false,
movies: {
enabled: document.getElementById('homeScreen_recentlyReleased_movies_enabled')?.checked !== false,
...getSectionConfig('homeScreen_recentlyReleased_movies', { includeName: true, defaultName: 'Recently Released Movies', includeSortOrder: false, includeOrder: true })
},
episodes: {
enabled: document.getElementById('homeScreen_recentlyReleased_episodes_enabled')?.checked !== false,
...getSectionConfig('homeScreen_recentlyReleased_episodes', { includeName: true, defaultName: 'Recently Aired Episodes', includeSortOrder: false, includeOrder: true })
}
},
trending: {
enabled: document.getElementById('homeScreen_trending_enabled')?.checked === true,
...getSectionConfig('homeScreen_trending', { includeName: true, defaultName: 'Trending' })
},
popularTVNetworks: {
enabled: document.getElementById('homeScreen_popularTVNetworks_enabled')?.checked === true,
minimumShowsForNetwork: parseInt(document.getElementById('homeScreen_popularTVNetworks_minimumShowsForNetwork')?.value || '5'),
...getSectionConfig('homeScreen_popularTVNetworks', { includeName: true, defaultName: 'Popular TV Networks' })
},
watchlist: {
enabled: document.getElementById('homeScreen_watchlist_enabled')?.checked === true,
...getSectionConfig('homeScreen_watchlist', { includeName: true, defaultName: 'Watchlist' })
},
watchAgain: {
enabled: document.getElementById('homeScreen_watchAgain_enabled')?.checked === true,
...getSectionConfig('homeScreen_watchAgain', { includeName: true, defaultName: 'Watch Again' })
},
upcoming: {
enabled: document.getElementById('homeScreen_upcoming_enabled')?.checked !== false,
...getSectionConfig('homeScreen_upcoming', { includeSortOrder: false, includeName: true, defaultName: 'Upcoming' })
},
imdbTop250: {
enabled: document.getElementById('homeScreen_imdbTop250_enabled')?.checked !== false,
...getSectionConfig('homeScreen_imdbTop250', { includeName: true, defaultName: 'IMDb Top 250' })
},
seasonal: {
enabled: document.getElementById('homeScreen_seasonal_enabled')?.checked !== false,
defaultItemLimit: 16,
defaultSortOrder: 'Random',
defaultCardFormat: 'Poster',
seasons: getSeasonalSeasons()
},
discovery: {
enabled: document.getElementById('homeScreen_discovery_enabled')?.checked !== false,
infiniteScroll: document.getElementById('homeScreen_discovery_infiniteScroll')?.checked !== false,
randomizeOrder: document.getElementById('homeScreen_discovery_randomizeOrder')?.checked === true,
minPeopleAppearances: parseInt(document.getElementById('homeScreen_discovery_minPeopleAppearances')?.value || '10'),
minGenreMovieCount: parseInt(document.getElementById('homeScreen_discovery_minGenreMovieCount')?.value || '50'),
spotlightDiscoveryChance: parseFloat(document.getElementById('homeScreen_discovery_spotlightDiscoveryChance')?.value || '0.5'),
defaultItemLimit: parseInt(document.getElementById('homeScreen_discovery_itemLimit')?.value || '16'),
defaultSortOrder: document.getElementById('homeScreen_discovery_sortOrder')?.value || 'Random',
defaultCardFormat: document.getElementById('homeScreen_discovery_cardFormat')?.value || 'Poster',
sectionTypes: (() => {
const sectionConfigs = {};
DISCOVERY_SECTION_DEFINITIONS.forEach(section => {
const prefix = `homeScreen_discovery_sectionTypes_${section.key}`;
const collectedConfig = getSectionConfig(prefix, { includeName: true, includeOrder: true, includeSortOrder: false, defaultName: section.defaultName });
collectedConfig.enabled = document.getElementById(`${prefix}_enabled`)?.checked !== false;
if (section.extras?.minimumItems !== undefined) {
const minimumValue = parseInt(document.getElementById(`${prefix}_minimumItems`)?.value || `${section.extras.minimumItems}`, 10);
collectedConfig.minimumItems = Number.isFinite(minimumValue) ? minimumValue : section.extras.minimumItems;
}
sectionConfigs[section.key] = collectedConfig;
});
return sectionConfigs;
})()
},
customSections: getCustomSections()
};
// Collect exclusive elsewhere config
config.exclusiveElsewhere = {
hideServerName: document.getElementById('exclusiveElsewhere_hideServerName')?.checked === true
};
// Collect search config
config.search = {
enableJellyseerr: document.getElementById('search_enableJellyseerr')?.checked === true
};
// Parse JSON fields
const skinsFromJson = parseJSONField('skinsJson', []);
config.themes = parseJSONField('themesJson', []);
config.customMenuLinks = parseJSONField('customMenuLinksJson', []);
// Collect skin enabled toggles and merge with JSON skins
// First, get the original config to preserve hidden skins
const originalConfig = await getKefinTweaksConfig();
const originalSkins = originalConfig.skins || [];
const hiddenSkins = originalSkins.filter(skin => skin.hidden === true);
// Collect enabled states from toggles
const skinEnabledStates = {};
modalInstance.dialogContent.querySelectorAll('[data-skin-name]').forEach(checkbox => {
const skinName = checkbox.getAttribute('data-skin-name');
skinEnabledStates[skinName] = checkbox.checked;
});
// Merge: start with hidden skins (preserve them), then add/update from JSON
config.skins = [...hiddenSkins];
// Add/update skins from JSON textarea
skinsFromJson.forEach(skin => {
const existingIndex = config.skins.findIndex(s => s.name === skin.name);
if (existingIndex !== -1) {
// Update existing skin (shouldn't happen for hidden, but just in case)
config.skins[existingIndex] = {
...config.skins[existingIndex],
...skin,
enabled: skinEnabledStates[skin.name] !== false // Default to true if not set
};
} else {
// Add new skin
config.skins.push({
...skin,
enabled: skinEnabledStates[skin.name] !== false,
hidden: false // Explicitly set for new skins
});
}
});
// Update enabled states for all skins (including hidden ones)
config.skins.forEach(skin => {
if (skinEnabledStates.hasOwnProperty(skin.name)) {
skin.enabled = skinEnabledStates[skin.name];
}
});
// Handle defaultSkin
if (config.defaultSkin === '') {
config.defaultSkin = null;
}
console.log('[KefinTweaks Configuration] Configuration collected:', config);
// Save to JavaScript Injector plugin
try {
await saveConfigToJavaScriptInjector(config);
// Show success toast
if (window.KefinTweaksToaster && window.KefinTweaksToaster.toast) {
window.KefinTweaksToaster.toast('KefinTweaks saved!');
}
} catch (error) {
console.error('[KefinTweaks Configuration] Error saving configuration:', error);
// Show error toast
if (window.KefinTweaksToaster && window.KefinTweaksToaster.toast) {
window.KefinTweaksToaster.toast(`Error saving configuration: ${error.message}. Please ensure the JavaScript Injector plugin is installed and you have administrator permissions.`, '5');
} else {
// Fallback to alert if toaster is not available
alert(`Error saving configuration: ${error.message}\n\nPlease ensure the JavaScript Injector plugin is installed and you have administrator permissions.`);
}
}
}
async function handleResetConfig(modalInstance) {
const userIsAdmin = await isAdmin();
if (!userIsAdmin) {
alert('You must be an administrator to reset configuration.');
return;
}
const confirmed = confirm('This will restore the KefinTweaks configuration to its defaults. It cannot be undone. Are you sure you want to continue?');
if (!confirmed) {
return;
}
try {
const defaultConfig = await loadDefaultConfig();
// Retain kefinTweaksRoot from existing config
const existingConfig = await getKefinTweaksConfig();
defaultConfig.kefinTweaksRoot = existingConfig.kefinTweaksRoot;
// Note: scriptRoot is no longer used - scripts are loaded from kefinTweaksRoot + '/scripts/'
await saveConfigToJavaScriptInjector(defaultConfig);
if (window.KefinTweaksToaster && window.KefinTweaksToaster.toast) {
window.KefinTweaksToaster.toast('Configuration reset to defaults.');
} else {
alert('Configuration reset to defaults.');
}
if (modalInstance && typeof modalInstance.close === 'function') {
modalInstance.close();
}
openConfigurationModal();
} catch (error) {
console.error('[KefinTweaks Configuration] Error resetting config:', error);
if (window.KefinTweaksToaster && window.KefinTweaksToaster.toast) {
window.KefinTweaksToaster.toast(`Error resetting configuration: ${error.message}`, '5');
} else {
alert(`Error resetting configuration: ${error.message}`);
}
}
}
// Helper to parse JSON fields safely
function parseJSONField(fieldId, defaultValue) {
try {
const field = document.getElementById(fieldId);
if (!field || !field.value.trim()) {
return defaultValue;
}
return JSON.parse(field.value);
} catch (error) {
console.error(`[KefinTweaks Configuration] Error parsing JSON field ${fieldId}:`, error);
alert(`Error parsing JSON in ${fieldId}: ${error.message}`);
return defaultValue;
}
}
// Create configuration button for Administration section
function createConfigButton() {
const button = document.createElement('div');
button.style.display = 'block';
button.style.padding = '0';
button.style.margin = '0';
button.className = 'listItem-border emby-button kefin-config-button';
button.setAttribute('data-kefintweaks-config-button', 'true');
button.onclick = (e) => {
e.preventDefault();
openConfigurationModal();
};
button.innerHTML = `
Configure KefinTweaks
`;
return button;
}
// Create dashboard side menu button
function createDashboardConfigButton() {
// Check if button already exists
if (document.querySelector('[data-kefintweaks-dashboard-config-button]')) {
return null;
}
const div = document.createElement('div');
div.className = 'MuiButtonBase-root MuiListItemButton-root MuiListItemButton-gutters MuiListItemButton-root MuiListItemButton-gutters kefin-config-button';
div.setAttribute('tabindex', '0');
div.setAttribute('data-kefintweaks-dashboard-config-button', 'true');
div.onclick = () => {
openConfigurationModal();
};
// Create icon with Material icon
const icon = document.createElement('div');
icon.className = 'MuiListItemIcon-root css-37qkju';
const iconSpan = document.createElement('span');
iconSpan.className = 'material-icons build MuiSvgIcon-root MuiSvgIcon-fontSizeMedium';
iconSpan.style.marginRight = '12px';
iconSpan.setAttribute('aria-hidden', 'true');
icon.appendChild(iconSpan);
// Create text
const text = document.createElement('div');
text.className = 'MuiListItemText-root css-f696uz';
const span = document.createElement('span');
span.className = 'MuiTypography-root MuiTypography-body1 MuiListItemText-primary css-hlxkyz';
span.textContent = 'KefinTweaks';
text.appendChild(span);
// Create ripple effect span
const ripple = document.createElement('span');
ripple.className = 'MuiTouchRipple-root css-w0pj6f';
div.appendChild(icon);
div.appendChild(text);
div.appendChild(ripple);
return div;
}
// Add configuration button to dashboard side menu
function addConfigButtonToDashboard() {
// Check if button already exists
if (document.querySelector('[data-kefintweaks-dashboard-config-button]')) {
return;
}
// Find the plugins section
const pluginsSection = document.querySelector('ul[aria-labelledby="plugins-subheader"]');
if (!pluginsSection) {
console.log('[KefinTweaks Configuration] Plugins section not found, retrying...');
setTimeout(addConfigButtonToDashboard, 500);
return;
}
// Create the button
const button = createDashboardConfigButton();
if (!button) {
return;
}
// Add button to the plugins section
pluginsSection.appendChild(button);
console.log('[KefinTweaks Configuration] Configuration button added to dashboard side menu');
}
// Add configuration button to Administration section
function addConfigButtonToAdminSection() {
// Check if button already exists (check for admin section button specifically)
if (document.querySelector('.adminSection [data-kefintweaks-config-button]')) {
return;
}
// Find the Administration section
const adminSection = document.querySelector('.adminSection.verticalSection');
if (!adminSection) {
console.log('[KefinTweaks Configuration] Administration section not found, retrying...');
setTimeout(addConfigButtonToAdminSection, 500);
return;
}
// Create and add the button
const button = createConfigButton();
adminSection.appendChild(button);
console.log('[KefinTweaks Configuration] Configuration button added to Administration section');
}
// Register onViewPage handler for mypreferencesmenu page and dashboard
function registerViewPageHandler() {
if (!window.KefinTweaksUtils || !window.KefinTweaksUtils.onViewPage) {
console.log('[KefinTweaks Configuration] KefinTweaksUtils.onViewPage not available, retrying...');
setTimeout(registerViewPageHandler, 1000);
return;
}
// Handler for dashboard and preferences pages
window.KefinTweaksUtils.onViewPage(async (view, element, hash) => {
// Check if user is admin before adding buttons
const userIsAdmin = await isAdmin();
if (!userIsAdmin) {
console.log('[KefinTweaks Configuration] User is not admin, not adding buttons');
return;
}
// Check if we're on the mypreferencesmenu page
if (hash && (hash.includes('mypreferencesmenu') || hash.includes('userpreferences') || hash.includes('preferences'))) {
console.log('[KefinTweaks Configuration] Preferences page detected');
// Wait a bit for the page to fully load
setTimeout(() => {
addConfigButtonToAdminSection();
}, 500);
}
// Check if we're on the dashboard page
if (view === 'dashboard' || view === 'configurationpage' || hash.includes('dashboard') || hash.includes('configurationpage')) {
console.log('[KefinTweaks Configuration] Dashboard page detected');
// Wait a bit for the page to fully load
setTimeout(() => {
addConfigButtonToDashboard();
}, 500);
}
});
console.log('[KefinTweaks Configuration] Registered onViewPage handler');
}
// Add configuration link to custom menu
async function addConfigLinkToCustomMenu() {
// Check if user is admin
const userIsAdmin = await isAdmin();
if (!userIsAdmin) {
console.log('[KefinTweaks Configuration] User is not admin, not adding menu link');
return;
}
// Check if utils is available
if (!window.KefinTweaksUtils || !window.KefinTweaksUtils.addCustomMenuLink) {
console.log('[KefinTweaks Configuration] KefinTweaksUtils.addCustomMenuLink not available, retrying...');
setTimeout(addConfigLinkToCustomMenu, 1000);
return;
}
// Use a special URL that we can intercept
const configUrl = '#';
// Add the menu link
const success = await window.KefinTweaksUtils.addCustomMenuLink(
'Configure',
'build',
configUrl,
false,
'.adminMenuOptions'
);
if (success) {
console.log('[KefinTweaks Configuration] Configuration link added to custom menu');
// Set up click handler to intercept navigation and open modal instead
setupConfigLinkClickHandler();
}
}
// Set up click handler for configuration menu link
function setupConfigLinkClickHandler() {
// Find the config button
const configButton = document.querySelector('.navMenuOption[data-name="configure"]');
if (!configButton) {
console.log('[KefinTweaks Configuration] Configuration button not found, retrying...');
setTimeout(setupConfigLinkClickHandler, 1000);
return;
}
// Add click handler to the config button
configButton.addEventListener('click', (e) => {
e.preventDefault();
openConfigurationModal();
});
}
// Handle direct navigation to config URL
function handleDirectConfigNavigation() {
if (window.location.hash === '#kefintweaks-config') {
console.log('[KefinTweaks Configuration] Direct navigation to config URL detected');
// Remove the hash to prevent navigation
window.history.replaceState(null, '', window.location.pathname + window.location.search);
// Open modal
openConfigurationModal();
}
}
// Set up hashchange listener for navigation after page load
function setupHashChangeListener() {
window.addEventListener('hashchange', () => {
if (window.location.hash === '#kefintweaks-config') {
console.log('[KefinTweaks Configuration] Hash change to config URL detected');
// Remove the hash to prevent navigation
window.history.replaceState(null, '', window.location.pathname + window.location.search);
// Open modal
openConfigurationModal();
}
});
}
// Initialize when DOM is ready
async function initialize() {
if (!window.ApiClient || !window.ApiClient._loggedIn) {
setTimeout(initialize, 1000);
return;
}
// Register view page handler
registerViewPageHandler();
// Add configuration link to custom menu
addConfigLinkToCustomMenu();
// Set up hashchange listener
setupHashChangeListener();
// Handle direct navigation to config URL
handleDirectConfigNavigation();
// Also check current page on initial load
const hash = window.location.hash;
const userIsAdmin = await isAdmin();
if (userIsAdmin) {
if (hash && (hash.includes('mypreferencesmenu') || hash.includes('userpreferences') || hash.includes('preferences'))) {
setTimeout(() => {
addConfigButtonToAdminSection();
}, 1000);
}
if (hash && hash.includes('dashboard')) {
setTimeout(() => {
addConfigButtonToDashboard();
}, 1000);
}
}
}
// Start initialization
if (document.readyState === 'loading') {
document.addEventListener('DOMContentLoaded', initialize);
} else {
initialize();
}
console.log('[KefinTweaks Configuration] Script loaded');
})();