// ==UserScript==
// @name WME Quick Zoom Button
// @name:en WME Quick Zoom Button
// @name:es Botón de Zoom Rápido WME
// @version 2025.08.04
// @description Fügt einen Button für temporären Zoom hinzu für bessere Chat sichtbarkeit und Auto-Sichtbarkeit
// @description:en Adds a button for temporary zoom for better chat visibility and auto-visibility
// @description:es Agrega un botón para zoom temporal para una mejor visibilidad del chat y auto-visibilidad
// @author Hiwi234
// @match https://www.waze.com/editor*
// @match https://www.waze.com/*/editor*
// @match https://beta.waze.com/editor*
// @match https://beta.waze.com/*/editor*
// @grant none
// @license MIT
// @namespace https://greasyfork.org/de/users/863740-horst-wittlich
// ==/UserScript==
(function() {
'use strict';
const STORAGE_KEY = {
AUTO: 'wme-quick-zoom-auto',
ZOOM: 'wme-quick-zoom-level',
VISIBILITY: 'wme-auto-visibility'
};
const translations = {
'de': {
buttonText: 'Quick Zoom',
buttonTooltip: 'Temporär auf Zoomstufe zoomen',
sliderLabel: 'Maximale Zoomstufe:',
autoLoadLabel: 'Automatisch beim Laden',
visibilityLabel: 'Immer sichtbar bleiben'
},
'en': {
buttonText: 'Quick Zoom',
buttonTooltip: 'Temporarily zoom to level',
sliderLabel: 'Maximum zoom level:',
autoLoadLabel: 'Automatic on load',
visibilityLabel: 'Always stay visible'
},
'es': {
buttonText: 'Zoom Rápido',
buttonTooltip: 'Zoom temporal al nivel',
sliderLabel: 'Nivel máximo de zoom:',
autoLoadLabel: 'Automático al cargar',
visibilityLabel: 'Permanecer siempre visible'
}
};
// State management
let isZooming = false;
let visibilityObserver = null;
let visibilityInterval = null;
let focusHandler = null;
function getLanguage() {
const lang = navigator.language.split('-')[0];
return translations[lang] ? lang : 'en';
}
function getAutoZoomSetting() {
try {
return localStorage.getItem(STORAGE_KEY.AUTO) === 'true';
} catch (e) {
console.warn('[WME Quick Zoom] localStorage access failed:', e);
return false;
}
}
function setAutoZoomSetting(value) {
try {
localStorage.setItem(STORAGE_KEY.AUTO, String(value));
} catch (e) {
console.warn('[WME Quick Zoom] localStorage write failed:', e);
}
}
function getVisibilitySetting() {
try {
return localStorage.getItem(STORAGE_KEY.VISIBILITY) === 'true';
} catch (e) {
console.warn('[WME Quick Zoom] localStorage access failed:', e);
return false;
}
}
function setVisibilitySetting(value) {
try {
localStorage.setItem(STORAGE_KEY.VISIBILITY, String(value));
} catch (e) {
console.warn('[WME Quick Zoom] localStorage write failed:', e);
}
}
function getZoomLevel() {
try {
const stored = localStorage.getItem(STORAGE_KEY.ZOOM);
return stored ? parseInt(stored) : 7;
} catch (e) {
console.warn('[WME Quick Zoom] localStorage access failed:', e);
return 7;
}
}
function setZoomLevel(value) {
try {
localStorage.setItem(STORAGE_KEY.ZOOM, String(value));
} catch (e) {
console.warn('[WME Quick Zoom] localStorage write failed:', e);
}
}
function ensureVisibility() {
if (!getVisibilitySetting()) return;
try {
console.log('[WME Quick Zoom] Prüfe Sichtbarkeit...');
// Strategie 1: Über WME API wenn verfügbar
if (window.W?.loginManager?.user && window.W.loginManager.user.getVisibility) {
try {
const currentVisibility = W.loginManager.user.getVisibility();
console.log('[WME Quick Zoom] API Visibility Status:', currentVisibility);
if (currentVisibility === false || currentVisibility === 'false') {
if (W.loginManager.user.setVisibility) {
W.loginManager.user.setVisibility(true);
console.log('[WME Quick Zoom] Sichtbarkeit über API gesetzt');
return;
}
}
} catch (apiError) {
console.log('[WME Quick Zoom] API-Methode fehlgeschlagen:', apiError.message);
}
}
// Strategie 2: Multi-Language Text-Erkennung
const invisibleTexts = [
'unsichtbar', 'invisible', 'offline', 'hidden',
'invisível', 'invisible', 'hors ligne', 'nascosto',
'оффлайн', 'niewidoczny', 'neviditelný', 'láthatatlan'
];
const visibleTexts = [
'sichtbar', 'visible', 'online', 'visible',
'visível', 'visible', 'en ligne', 'visibile',
'онлайн', 'widoczny', 'viditelný', 'látható'
];
// Strategie 3: Erweiterte Selektor-Suche
const selectors = [
// Spezifische Waze-Selektoren
'span.editor-visibility.label',
'.editor-visibility',
'.online-editors-list .editor-visibility',
'[data-testid*="visibility"]',
'[data-qa*="visibility"]',
// Generische Selektoren
'[class*="visibility"]',
'[class*="editor-status"]',
'[class*="online-status"]',
// Button-Selektoren
'wz-button[color="clear-icon"]',
'button[class*="visibility"]',
'.visibility-toggle',
// Icon-basierte Selektoren
'[class*="icon-eye"]',
'[class*="eye-slash"]',
'wz-icon[name*="eye"]',
'wz-icon[name*="visible"]',
// Aria und Title Attribute
'[aria-label*="visible"], [aria-label*="sichtbar"]',
'[title*="visible"], [title*="sichtbar"]',
'[tooltip*="visible"], [tooltip*="sichtbar"]'
];
for (const selector of selectors) {
const elements = document.querySelectorAll(selector);
for (const element of elements) {
if (checkAndToggleVisibility(element, invisibleTexts, visibleTexts)) {
return; // Erfolgreich geändert
}
}
}
// Strategie 4: Icon-basierte Erkennung
const iconElements = document.querySelectorAll('wz-icon, i[class*="icon"], [class*="fa-"], svg');
for (const icon of iconElements) {
const iconName = icon.getAttribute('name') || icon.className || '';
const parentText = icon.closest('[class*="editor"], [class*="visibility"], li, div')?.textContent || '';
// Prüfe Icon-Namen und Parent-Text
if ((iconName.includes('eye') && (iconName.includes('slash') || iconName.includes('off'))) ||
invisibleTexts.some(text => parentText.toLowerCase().includes(text))) {
const clickable = findClickableParent(icon);
if (clickable) {
console.log('[WME Quick Zoom] Icon-basierte Erkennung: Unsichtbar -> Sichtbar');
clickable.click();
return;
}
}
}
// Strategie 5: Position-basierte Suche (Online-Editoren Liste)
const onlineEditorsList = document.querySelector('.online-editors-list, #online-editors, [class*="editor-list"]');
if (onlineEditorsList) {
const userItems = onlineEditorsList.querySelectorAll('li, .editor-item, [class*="user"], [class*="editor"]');
for (const item of userItems) {
// Suche nach dem aktuellen Benutzer (oft markiert)
if (item.classList.contains('current-user') ||
item.querySelector('.current-user') ||
item.getAttribute('data-current') === 'true') {
if (checkAndToggleVisibility(item, invisibleTexts, visibleTexts)) {
return;
}
}
}
}
console.log('[WME Quick Zoom] Keine Sichtbarkeits-Einstellung gefunden');
} catch (error) {
console.warn('[WME Quick Zoom] Fehler beim Setzen der Sichtbarkeit:', error);
}
}
function checkAndToggleVisibility(element, invisibleTexts, visibleTexts) {
try {
const text = (element.textContent || '').toLowerCase().trim();
const ariaLabel = (element.getAttribute('aria-label') || '').toLowerCase();
const title = (element.getAttribute('title') || '').toLowerCase();
const className = (element.className || '').toLowerCase();
const dataAttrs = Array.from(element.attributes)
.filter(attr => attr.name.startsWith('data-'))
.map(attr => attr.value.toLowerCase())
.join(' ');
const allText = `${text} ${ariaLabel} ${title} ${className} ${dataAttrs}`;
// Prüfe auf "unsichtbar" Begriffe
const isInvisible = invisibleTexts.some(invisibleText =>
allText.includes(invisibleText));
if (isInvisible) {
console.log('[WME Quick Zoom] Unsichtbar-Status erkannt:', text || className);
const clickable = findClickableParent(element);
if (clickable) {
console.log('[WME Quick Zoom] Klicke Sichtbarkeits-Button...');
// Simuliere verschiedene Click-Events für Kompatibilität
const clickEvents = ['mousedown', 'click', 'mouseup'];
clickEvents.forEach(eventType => {
try {
const event = new MouseEvent(eventType, {
bubbles: true,
cancelable: true,
view: window
});
clickable.dispatchEvent(event);
} catch (eventError) {
// Fallback zu einfachem click()
if (eventType === 'click') {
clickable.click();
}
}
});
console.log('[WME Quick Zoom] Sichtbarkeit geändert');
return true;
}
}
return false;
} catch (error) {
console.warn('[WME Quick Zoom] Fehler bei Visibility-Check:', error);
return false;
}
}
function findClickableParent(element) {
// Verschiedene Klick-Strategien
const strategies = [
// Direkt klickbar
() => element.matches('button, wz-button, [role="button"], [clickable="true"]') ? element : null,
// Parent-Suche
() => element.closest('button, wz-button, [role="button"], [clickable="true"]'),
// Sibling-Suche
() => element.parentElement?.querySelector('button, wz-button, [role="button"]'),
// Container-Suche
() => element.closest('li, .editor-item, [class*="user"]')?.querySelector('button, wz-button, [role="button"]'),
// Icon-Parent-Suche
() => element.closest('[class*="icon"], .visibility')?.parentElement?.querySelector('button, wz-button'),
// Fallback: Parent Element selbst
() => {
let parent = element.parentElement;
while (parent && parent !== document.body) {
if (parent.onclick || parent.addEventListener) {
return parent;
}
parent = parent.parentElement;
}
return null;
}
];
for (const strategy of strategies) {
try {
const clickable = strategy();
if (clickable && typeof clickable.click === 'function') {
return clickable;
}
} catch (error) {
// Nächste Strategie versuchen
continue;
}
}
return null;
}
function stopVisibilityMonitoring() {
if (visibilityObserver) {
visibilityObserver.disconnect();
visibilityObserver = null;
console.log('[WME Quick Zoom] MutationObserver gestoppt');
}
if (visibilityInterval) {
clearInterval(visibilityInterval);
visibilityInterval = null;
console.log('[WME Quick Zoom] Interval gestoppt');
}
// Cleanup aller Event Handler
if (window.wmeQuickZoomEventHandlers) {
Object.entries(window.wmeQuickZoomEventHandlers).forEach(([event, handler]) => {
try {
window.removeEventListener(event, handler);
document.removeEventListener(event, handler);
} catch (error) {
// Event removal failed, continue
}
});
delete window.wmeQuickZoomEventHandlers;
}
// Cleanup Timeout
if (window.wmeQuickZoomVisibilityTimeout) {
clearTimeout(window.wmeQuickZoomVisibilityTimeout);
delete window.wmeQuickZoomVisibilityTimeout;
}
if (focusHandler) {
window.removeEventListener('focus', focusHandler);
focusHandler = null;
}
}
function startVisibilityMonitoring() {
if (!getVisibilitySetting()) return;
// Stoppe vorherige Überwachung
stopVisibilityMonitoring();
console.log('[WME Quick Zoom] Starte erweiterte Sichtbarkeits-Überwachung...');
// Multi-Strategy MutationObserver
visibilityObserver = new MutationObserver((mutations) => {
try {
let shouldCheck = false;
for (const mutation of mutations) {
// Überwache verschiedene Arten von Änderungen
if (mutation.type === 'childList') {
// Neue Elemente hinzugefügt/entfernt
const relevantChanges = [...mutation.addedNodes, ...mutation.removedNodes]
.some(node => {
if (node.nodeType === Node.ELEMENT_NODE) {
return isRelevantForVisibility(node);
}
return false;
});
if (relevantChanges) shouldCheck = true;
}
if (mutation.type === 'attributes') {
// Attribut-Änderungen
const target = mutation.target;
if (isRelevantForVisibility(target) ||
target.closest?.('.online-editors-list, [class*="editor"], [class*="visibility"]')) {
shouldCheck = true;
}
}
if (mutation.type === 'characterData') {
// Text-Änderungen
const parent = mutation.target.parentElement;
if (parent && isRelevantForVisibility(parent)) {
shouldCheck = true;
}
}
}
if (shouldCheck) {
// Debounced Check - verhindert zu häufige Ausführungen
clearTimeout(window.wmeQuickZoomVisibilityTimeout);
window.wmeQuickZoomVisibilityTimeout = setTimeout(() => {
ensureVisibility();
}, 300);
}
} catch (error) {
console.warn('[WME Quick Zoom] Fehler in MutationObserver:', error);
}
});
// Erweiterte Beobachtung verschiedener Container
const observeTargets = [
// Haupt-Editoren Container
() => document.getElementById('online-editors'),
() => document.querySelector('.online-editors-list'),
() => document.querySelector('[class*="editor-list"]'),
() => document.querySelector('#sidebar'),
() => document.querySelector('.sidebar'),
// Fallback: Body
() => document.body
];
for (const getTarget of observeTargets) {
try {
const target = getTarget();
if (target) {
visibilityObserver.observe(target, {
childList: true,
subtree: true,
attributes: true,
characterData: true,
attributeFilter: [
'class', 'aria-label', 'title', 'data-testid',
'data-qa', 'name', 'tooltip', 'data-current',
'data-visible', 'data-status'
]
});
console.log('[WME Quick Zoom] Observer aktiv auf:', target.tagName, target.className);
break; // Nur ersten verfügbaren Container überwachen
}
} catch (error) {
console.warn('[WME Quick Zoom] Fehler beim Observer-Setup:', error);
continue;
}
}
// Adaptive Interval-Überprüfung
let intervalDuration = 15000; // Start mit 15 Sekunden
const maxInterval = 60000; // Maximum 60 Sekunden
const minInterval = 5000; // Minimum 5 Sekunden
visibilityInterval = setInterval(() => {
try {
const wasVisible = checkCurrentVisibilityState();
ensureVisibility();
// Adaptive Interval-Anpassung
if (!wasVisible) {
// Wenn unsichtbar war, überprüfe häufiger
intervalDuration = Math.max(minInterval, intervalDuration - 2000);
} else {
// Wenn sichtbar war, überprüfe seltener
intervalDuration = Math.min(maxInterval, intervalDuration + 5000);
}
// Restart interval mit neuer Duration
clearInterval(visibilityInterval);
visibilityInterval = setInterval(arguments.callee, intervalDuration);
} catch (error) {
console.warn('[WME Quick Zoom] Fehler im Visibility-Interval:', error);
}
}, intervalDuration);
// Event-basierte Trigger
const eventHandlers = {
// Fokus-Events
focus: () => setTimeout(ensureVisibility, 1000),
// Visibility API
visibilitychange: () => {
if (!document.hidden) {
setTimeout(ensureVisibility, 500);
}
},
// Custom Waze Events (falls verfügbar)
'wme-sidebar-change': () => setTimeout(ensureVisibility, 200),
'wme-tab-switch': () => setTimeout(ensureVisibility, 200),
// Resize Events (UI könnte sich ändern)
resize: () => setTimeout(ensureVisibility, 1000)
};
Object.entries(eventHandlers).forEach(([event, handler]) => {
try {
window.addEventListener(event, handler, { passive: true });
document.addEventListener(event, handler, { passive: true });
} catch (error) {
// Event nicht unterstützt, ignorieren
}
});
// Storage für Event Cleanup
window.wmeQuickZoomEventHandlers = eventHandlers;
// Erste Überprüfung mit verschiedenen Delays
[1000, 3000, 5000].forEach(delay => {
setTimeout(() => {
try {
ensureVisibility();
} catch (error) {
console.warn(`[WME Quick Zoom] Fehler bei verzögerter Überprüfung (${delay}ms):`, error);
}
}, delay);
});
}
function isRelevantForVisibility(element) {
if (!element || !element.tagName) return false;
const relevantSelectors = [
'online-editors', 'editor-visibility', 'visibility',
'editor-list', 'user-list', 'editor-item', 'wz-button',
'icon', 'eye', 'current-user', 'editor-status'
];
const elementInfo = `${element.className} ${element.id} ${element.tagName}`.toLowerCase();
return relevantSelectors.some(selector =>
elementInfo.includes(selector)) ||
element.querySelector?.('.editor-visibility, [class*="visibility"], wz-button') ||
element.matches?.('wz-button, [role="button"], [class*="visibility"]');
}
function checkCurrentVisibilityState() {
try {
// Versuche aktuellen Status zu ermitteln
const invisibleTexts = ['unsichtbar', 'invisible', 'offline', 'hidden'];
const allElements = document.querySelectorAll('[class*="visibility"], [class*="editor"], .online-editors-list *');
for (const element of allElements) {
const text = (element.textContent || '').toLowerCase();
const className = (element.className || '').toLowerCase();
const ariaLabel = (element.getAttribute('aria-label') || '').toLowerCase();
if (invisibleTexts.some(invisible =>
text.includes(invisible) || className.includes(invisible) || ariaLabel.includes(invisible))) {
return false; // Unsichtbar gefunden
}
}
return true; // Annahme: Sichtbar
} catch (error) {
return true; // Bei Fehler annehmen dass sichtbar
}
}
async function performQuickZoom() {
if (isZooming) {
console.log('[WME Quick Zoom] Zoom bereits aktiv, überspringe...');
return;
}
try {
if (!window.W?.map?.olMap) {
console.warn('[WME Quick Zoom] WME map nicht verfügbar');
return;
}
isZooming = true;
const originalZoom = W.map.olMap.getZoom();
const targetZoom = getZoomLevel();
console.log(`[WME Quick Zoom] Zooming from ${originalZoom} to ${targetZoom}`);
W.map.olMap.zoomTo(targetZoom);
// Promise für verzögerte Rückkehr zum ursprünglichen Zoom
return new Promise(resolve => {
setTimeout(() => {
try {
if (window.W?.map?.olMap) {
W.map.olMap.zoomTo(originalZoom);
console.log(`[WME Quick Zoom] Restored zoom to ${originalZoom}`);
}
} catch (error) {
console.error('[WME Quick Zoom] Error restoring zoom:', error);
} finally {
isZooming = false;
resolve();
}
}, 2000);
});
} catch (error) {
console.error('[WME Quick Zoom] Error in performQuickZoom:', error);
isZooming = false;
}
}
function createStyles() {
// Prüfe ob Styles bereits existieren
if (document.getElementById('wme-quick-zoom-styles')) {
return;
}
const style = document.createElement('style');
style.id = 'wme-quick-zoom-styles';
style.textContent = `
.quick-zoom-container {
display: flex;
flex-direction: column;
gap: 10px;
padding: 10px;
}
.quick-zoom-slider-container {
display: flex;
flex-direction: column;
gap: 5px;
}
.quick-zoom-checkbox-container {
display: flex;
align-items: center;
gap: 5px;
}
.quick-zoom-label {
font-size: 12px;
color: inherit;
}
.quick-zoom-slider {
width: 100%;
}
.quick-zoom-floating-button {
position: fixed;
bottom: 20px;
left: 20px;
z-index: 1000;
background-color: #ffffff;
border: 1px solid #cccccc;
padding: 8px 15px;
border-radius: 20px;
box-shadow: 0 2px 4px rgba(0,0,0,0.2);
cursor: pointer;
font-weight: bold;
font-family: inherit;
font-size: 12px;
transition: background-color 0.3s ease, box-shadow 0.3s ease;
}
.quick-zoom-floating-button:hover {
background-color: #f0f0f0;
box-shadow: 0 4px 8px rgba(0,0,0,0.3);
}
.quick-zoom-floating-button:active {
background-color: #e0e0e0;
transform: translateY(1px);
}
`;
document.head.appendChild(style);
}
async function initializeQuickZoom() {
try {
// Warte bis WME vollständig geladen ist
if (!window.W?.userscripts?.registerSidebarTab) {
console.warn('[WME Quick Zoom] WME userscripts nicht verfügbar, warte...');
setTimeout(initializeQuickZoom, 1000);
return;
}
console.log('[WME Quick Zoom] Initialisiere...');
const i18n = translations[getLanguage()];
// Erstelle CSS-Styles
createStyles();
// Registriere Sidebar-Tab
const { tabLabel, tabPane } = W.userscripts.registerSidebarTab("quick-zoom-script");
tabLabel.innerText = 'QZ';
tabLabel.title = i18n.buttonText;
// Erstelle Container
const container = document.createElement('div');
container.className = 'quick-zoom-container';
// Sidebar Button
const sidebarButton = document.createElement('button');
sidebarButton.className = 'waze-btn waze-btn-small';
sidebarButton.innerText = i18n.buttonText;
sidebarButton.title = `${i18n.buttonTooltip} ${getZoomLevel()}`;
sidebarButton.type = 'button';
// Floating Button
const floatingButton = document.createElement('button');
floatingButton.innerText = 'QZ';
floatingButton.title = `${i18n.buttonTooltip} ${getZoomLevel()}`;
floatingButton.className = 'quick-zoom-floating-button';
floatingButton.type = 'button';
// Slider Container
const sliderContainer = document.createElement('div');
sliderContainer.className = 'quick-zoom-slider-container';
const sliderLabel = document.createElement('label');
sliderLabel.textContent = i18n.sliderLabel;
sliderLabel.className = 'quick-zoom-label';
const sliderValue = document.createElement('span');
sliderValue.className = 'quick-zoom-label';
sliderValue.textContent = getZoomLevel();
const slider = document.createElement('input');
slider.type = 'range';
slider.min = '4';
slider.max = '12';
slider.value = getZoomLevel();
slider.className = 'quick-zoom-slider';
// Event Handlers mit passiven Events
const zoomHandler = (event) => {
event.preventDefault();
if (!isZooming) {
performQuickZoom().catch(error => {
console.error('[WME Quick Zoom] Zoom-Fehler:', error);
});
}
};
const sliderHandler = (event) => {
const value = event.target.value;
sliderValue.textContent = value;
setZoomLevel(value);
const tooltip = `${i18n.buttonTooltip} ${value}`;
sidebarButton.title = tooltip;
floatingButton.title = tooltip;
};
// Event Listeners hinzufügen
slider.addEventListener('input', sliderHandler, { passive: true });
sidebarButton.addEventListener('click', zoomHandler);
floatingButton.addEventListener('click', zoomHandler);
// Auto-Zoom Checkbox
const checkboxContainer = document.createElement('div');
checkboxContainer.className = 'quick-zoom-checkbox-container';
const checkbox = document.createElement('input');
checkbox.type = 'checkbox';
checkbox.id = 'auto-quick-zoom-' + Date.now();
checkbox.checked = getAutoZoomSetting();
const label = document.createElement('label');
label.htmlFor = checkbox.id;
label.textContent = i18n.autoLoadLabel;
label.className = 'quick-zoom-label';
checkbox.addEventListener('change', (event) => {
setAutoZoomSetting(event.target.checked);
}, { passive: true });
// Visibility Checkbox
const visibilityCheckboxContainer = document.createElement('div');
visibilityCheckboxContainer.className = 'quick-zoom-checkbox-container';
const visibilityCheckbox = document.createElement('input');
visibilityCheckbox.type = 'checkbox';
visibilityCheckbox.id = 'auto-visibility-' + Date.now();
visibilityCheckbox.checked = getVisibilitySetting();
const visibilityLabel = document.createElement('label');
visibilityLabel.htmlFor = visibilityCheckbox.id;
visibilityLabel.textContent = i18n.visibilityLabel;
visibilityLabel.className = 'quick-zoom-label';
visibilityCheckbox.addEventListener('change', (event) => {
setVisibilitySetting(event.target.checked);
if (event.target.checked) {
setTimeout(startVisibilityMonitoring, 500);
} else {
stopVisibilityMonitoring();
}
}, { passive: true });
// DOM aufbauen
sliderContainer.appendChild(sliderLabel);
sliderContainer.appendChild(slider);
sliderContainer.appendChild(sliderValue);
checkboxContainer.appendChild(checkbox);
checkboxContainer.appendChild(label);
visibilityCheckboxContainer.appendChild(visibilityCheckbox);
visibilityCheckboxContainer.appendChild(visibilityLabel);
container.appendChild(sidebarButton);
container.appendChild(sliderContainer);
container.appendChild(checkboxContainer);
container.appendChild(visibilityCheckboxContainer);
tabPane.appendChild(container);
document.body.appendChild(floatingButton);
// Warte bis Tab verbunden ist
await W.userscripts.waitForElementConnected(tabPane);
// Auto-Zoom ausführen wenn aktiviert
if (getAutoZoomSetting()) {
setTimeout(() => {
performQuickZoom().catch(error => {
console.error('[WME Quick Zoom] Auto-Zoom Fehler:', error);
});
}, 2000);
}
// Visibility Monitoring starten wenn aktiviert
if (getVisibilitySetting()) {
setTimeout(startVisibilityMonitoring, 1000);
}
console.log('[WME Quick Zoom] Erfolgreich initialisiert');
} catch (error) {
console.error('[WME Quick Zoom] Initialisierungs-Fehler:', error);
}
}
// Cleanup beim Verlassen der Seite
window.addEventListener('beforeunload', () => {
stopVisibilityMonitoring();
}, { passive: true });
// Verbesserte Initialisierung
function initialize() {
try {
if (window.W?.userscripts?.state?.isReady) {
initializeQuickZoom();
} else if (window.W?.userscripts) {
document.addEventListener("wme-ready", initializeQuickZoom, {
once: true,
passive: true
});
} else {
// Warte auf WME
let attempts = 0;
const maxAttempts = 60; // 30 Sekunden maximum
const checkWME = () => {
attempts++;
if (window.W?.userscripts) {
if (window.W.userscripts.state?.isReady) {
initializeQuickZoom();
} else {
document.addEventListener("wme-ready", initializeQuickZoom, {
once: true,
passive: true
});
}
} else if (attempts < maxAttempts) {
setTimeout(checkWME, 500);
} else {
console.error('[WME Quick Zoom] WME konnte nicht geladen werden nach', maxAttempts * 500, 'ms');
}
};
checkWME();
}
} catch (error) {
console.error('[WME Quick Zoom] Initialisierungs-Setup-Fehler:', error);
}
}
// Start initialization
if (document.readyState === 'loading') {
document.addEventListener('DOMContentLoaded', initialize, {
once: true,
passive: true
});
} else {
initialize();
}
})();
