Отключить-Включить модальное окно на загрузке

async function initializeEventListenersRemoval(delay) {
    const targetToListeners = new WeakMap();
    const entryToOnceCb = new WeakMap();
    const dynamicallyRemovedEntries = new WeakSet();

    // Эта функция возвращает неизменяемый список слушателей
    function getEventListeners(target, type, phase) {
        const allListeners = targetToListeners.get(target);
        if (!allListeners) return [];
        if (!type && !phase) return allListeners.slice();
        if (!allListeners[type]) return [];
        if (!phase || phase === Event.AT_TARGET) return allListeners[type].slice();
        if (phase === Event.CAPTURING_PHASE) return allListeners[type].filter(listener => listener.capture);
        if (phase === Event.BUBBLING_PHASE) return allListeners[type].filter(listener => !listener.capture);
        throw new Error("Illegal event phase for getEventListeners: phase can only be Event.BUBBLING_PHASE, Event.CAPTURING_PHASE, or Event.AT_TARGET.");
    }

    function findEquivalentListener(registryList, listener, useCapture) {
        return registryList.findIndex(cbOptions => cbOptions.listener === listener && cbOptions.capture === useCapture);
    }

    function makeEntry(target, type, listener, options) {
        const entry = options instanceof Object ?
            Object.assign({}, options, { listener, type }) :
            { listener, type, capture: !!options };
        entry.capture = !!entry.capture;
        entry.bubbles = !!entry.bubbles;
        entry.once = !!entry.once;
        entry.passive = !!entry.passive;
        entry.target = target;
        Object.defineProperty(entry, "removed", {
            get: function () {
                return dynamicallyRemovedEntries.has(this);
            }
        });
        Object.freeze(entry);
        return entry;
    }

    function addListener(target, type, listener, options) {
        let allListeners = targetToListeners.get(target);
        if (!allListeners) targetToListeners.set(target, allListeners = {});
        let typeListeners = allListeners[type] || (allListeners[type] = []);
        const capture = !!(options instanceof Object ? options.capture : options);
        const index = findEquivalentListener(typeListeners, listener, capture);
        if (index !== -1) return null;
        const entry = makeEntry(target, type, listener, options);
        typeListeners.push(entry);
        return entry;
    }

    function removeListener(target, type, listener, options) {
        let allListeners = targetToListeners.get(target);
        if (!allListeners) return null;
        let typeListeners = allListeners[type];
        if (!typeListeners) return null;
        const capture = !!(options instanceof Object ? options.capture : options);
        const index = findEquivalentListener(typeListeners, listener, capture);
        if (index === -1) return null;
        return typeListeners.splice(index, 1)[0];  //mutates the list in the targetToListeners
    }

    function addEventTargetRegistry(EventTargetPrototype = EventTarget.prototype) {
        const ogAdd = EventTargetPrototype.addEventListener;
        const ogRemove = EventTargetPrototype.removeEventListener;

        function addEntry(entry) {
            let target = entry.target;
            let type = entry.type;
            let cb = entry.listener;
            let options = entry;

            if (entry.once) {
                options = Object.assign({}, options);
                options.once = false;
                cb = function (e) {
                    removeEntry(entry);
                    entry.listener.call(this, e);
                }
                entryToOnceCb.set(entry, cb);
            }
            ogAdd.call(target, type, cb, options);
        }

        function removeEntry(entry) {
            let cb = entryToOnceCb.get(entry) || entry.listener;
            ogRemove.call(entry.target, entry.type, cb, entry);
        }

        function addEventListenerRegistry(type, listener, options) {
            const entry = addListener(this, type, listener, options);
            if (!entry) //addListener returns false when equivalent listener is already added.
                return;
            addEntry(entry);
        }

        function removeEventListenerRegistry(type, listener, options) {
            const entry = removeListener(this, type, listener, options);
            if (!entry)  //removeListener returns false when there is no listener to be removed.
                return;
            dynamicallyRemovedEntries.add(entry);
            removeEntry(entry);
        }

        Object.defineProperty(EventTargetPrototype, "addEventListener", { value: addEventListenerRegistry });
        Object.defineProperty(EventTargetPrototype, "removeEventListener", { value: removeEventListenerRegistry });

        return getEventListeners;
    }

    // Инициализируем систему отслеживания событий
    const getEventListeners2 = addEventTargetRegistry();

    // Теперь функция getEventListeners доступна глобально
    window.getEventListeners = getEventListeners2;

    // Удаление обработчиков событий с задержкой
    setTimeout(function () {
        var forms = document.querySelectorAll('form');
        forms.forEach(function (form) {
            form.onsubmit = null;
        });

        // Удалите обработчик события beforeunload
        window.onbeforeunload = null;

        // Удалите любые установленные ранее слушатели события beforeunload
        var listeners = getEventListeners(window, 'beforeunload');
        if (Array.isArray(listeners) && listeners.length > 0) {
            listeners.forEach(function (listener) {
                window.removeEventListener('beforeunload', listener.listener);
            });
        }

        // Удалите все обработчики событий beforeunload
        var oldOnBeforeUnload = window.onbeforeunload;
        window.onbeforeunload = null;
        if (oldOnBeforeUnload && typeof oldOnBeforeUnload.listener === 'function') {
            window.removeEventListener('beforeunload', oldOnBeforeUnload.listener);
        }
    }, delay); // задержка в миллисекундах
}

// Вызов функции с задержкой в x секунды
await initializeEventListenersRemoval(1000);


async function enableBeforeUnload() {
    setTimeout(() => {
        // Функция для преобразования массива объектов в словарь
        function transformToDict(data) {
            return data.reduce((result, item) => {
                result[item.fieldName] = item.currentValue;
                return result;
            }, {});
        }

        // Функция для сравнения двух объектов
        function compareObjects(obj1, obj2) {
            const keys1 = Object.keys(obj1);
            const keys2 = Object.keys(obj2);

            if (keys1.length !== keys2.length) {
                return false;
            }

            for (let key of keys1) {
                if (obj1[key] !== obj2[key]) {
                    return false;
                }
            }

            return true;
        }

        // Функция для валидации значений формы
        function validateFormValues(data) {
            // Преобразование formValues в словарь
            const formValues = s_widgets.getForm('remTask');
            const transformedData = transformToDict(formValues.getChanges());

            // Преобразование data (который уже является объектом) в словарь для сравнения
            const originalData = data;
            console.log(transformedData);
            console.log(data);

            // Сравнение оригинальных данных и трансформированных данных
            return compareObjects(originalData, transformedData);
        }

        // Пример использования
        const formValues = s_widgets.getForm('remTask');
        const data = formValues.getAllFields().data;
        // Создание копии объекта data
        const dataCopy = JSON.parse(JSON.stringify(data));


        window.onbeforeunload = function (event) {
            const isValid = validateFormValues(dataCopy);
            console.log(isValid);

            if (isValid) {
                window.onbeforeunload = null;
            } else {
                const confirmationMessage = 'You have unsaved changes. Do you really want to leave?';
                event.returnValue = confirmationMessage; // For most browsers
                return confirmationMessage; // For some older browsers
            }
        };
    }, 2000);
}

// Вызов функции для включения предупреждения
await enableBeforeUnload();