# Використовуючи SweetAlert2 для індикаторів завантаження HTMX

<datetime class="hidden">2025-04-21T20:05</datetime>

<!--category-- Javascript, HTMX -->
# Введение

Під час роботи я використовував і зловживав HTMX для створення інтерфейсу адміністрації. [SweetAlert2](https://sweetalert2.github.io/#examples) Бібліотека Javascript [для моїх повідомлень про potwierdzenie](https://www.mostlylucid.net/blog/showingtoastandswappingwithhtmx#additional-htmx-features). Це чудово працює, але я також хотів використовувати їх, щоб замінити мої вказівники навантаження HTMX

Це було випробуванням, тому я подумав, що я зможу задокументувати його тут, щоб вам врятувати той самий біль.

 <p style="color:red">Warning I'm a C# coder my Javascript is likely horrible.</p>
[TOC]

# Проблема

Тож HTMX дуже розумний. `hx-indicator` звичайно ви можете налаштувати індикатор завантаження для ваших HTTPMX запитів. Зазвичай це HTML елемент в вашій сторінці, як

```html

<div id="loading-modal" class="modal htmx-indicator">
    <div class="modal-box flex flex-col items-center justify-center bg-base-200 border border-base-300 shadow-xl rounded-xl text-base-content dark text-center ">
        <div class="flex flex-col items-center space-y-4">
            <h2 class="text-lg font-semibold tracking-wide">Loading...</h2>
            <span class="loading loading-dots loading-xl text-4xl text-stone-200"></span>
        </div>
    </div>
</div>
```

Тоді, коли ви хочете його використати, ви'd зробите ваш HTMX запит `hx-indicator="#loading-modal"` і він покаже modal, коли запрошування відбувається ([подивіться тут для деталей](https://htmx.org/attributes/hx-indicator/)).

Тепер HTMX робить дещо розумну магію, використовуючи `request` об 'єкт [він просувається всередині](https://github.com/bigskysoftware/htmx/blob/86893ebf4cb0f38484a522044f9a07cdd79398fa/src/htmx.js#L3293)

```javascript
  function addRequestIndicatorClasses(elt) {
    let indicators = /** @type Element[] */ (findAttributeTargets(elt, 'hx-indicator'))
    if (indicators == null) {
      indicators = [elt]
    }
    forEach(indicators, function(ic) {
      const internalData = getInternalData(ic)
      internalData.requestCount = (internalData.requestCount || 0) + 1
      ic.classList.add.call(ic.classList, htmx.config.requestClass)
    })
    return indicators
  }

```

Таким чином, їх замінити трохи складно.

# Рішення

Тож я вирішив: ( не тому, що мені довелося ,, тому що мені потрібно було МSK2 замінити навігаційний індикатор HTMX з модулем SweetAlert
В будь-якому разі, ось код, який я придумав:

Ви'd починаєте з того, що Importуєте SweetAlert2 в HTML M SK2 як скрипт & стильні ярлики МSK4 МSK5 Importуємо його для веб-пакета чи подібного.[подивіться на їхні документи для цього).
](https://sweetalert2.github.io/#download)

Після того, як npm його заinstalував, ви можете внести його ось так у ваш файл JS.

```javascript
import Swal from 'sweetalert2';
```

Тоді мій головний код виглядає ось так:

```javascript
import Swal from 'sweetalert2';

const SWEETALERT_PATH_KEY = 'swal-active-path'; // Stores the path of the current SweetAlert
const SWEETALERT_HISTORY_RESTORED_KEY = 'swal-just-restored'; // Flag for navigation from browser history
const SWEETALERT_TIMEOUT_MS = 10000; // Timeout for automatically closing the loader

let swalTimeoutHandle = null;

export function registerSweetAlertHxIndicator() {
    document.body.addEventListener('htmx:configRequest', function (evt) {
        const trigger = evt.detail.elt;
        const indicatorAttrSource = getIndicatorSource(trigger);
        if (!indicatorAttrSource) return;

        const path = getRequestPath(evt.detail);
        if (!path) return;

        const currentPath = sessionStorage.getItem(SWEETALERT_PATH_KEY);

        // Show SweetAlert only if the current request path differs from the previous one
        if (currentPath !== path) {
            closeSweetAlertLoader();
            sessionStorage.setItem(SWEETALERT_PATH_KEY, path);
            evt.detail.indicator = null; // Disable HTMX's default indicator behavior

            Swal.fire({
                title: 'Loading...',
                allowOutsideClick: false,
                allowEscapeKey: false,
                showConfirmButton: false,
                theme: 'dark',
                didOpen: () => {
                    // Cancel immediately if restored from browser history
                    if (sessionStorage.getItem(SWEETALERT_HISTORY_RESTORED_KEY) === 'true') {
                        sessionStorage.removeItem(SWEETALERT_HISTORY_RESTORED_KEY);
                        Swal.close();
                        return;
                    }

                    Swal.showLoading();
                    document.dispatchEvent(new CustomEvent('sweetalert:opened'));

                    // Set timeout to auto-close if something hangs
                    clearTimeout(swalTimeoutHandle);
                    swalTimeoutHandle = setTimeout(() => {
                        if (Swal.isVisible()) {
                            console.warn('SweetAlert loading modal closed after timeout.');
                            closeSweetAlertLoader();
                        }
                    }, SWEETALERT_TIMEOUT_MS);
                },
                didClose: () => {
                    document.dispatchEvent(new CustomEvent('sweetalert:closed'));
                    sessionStorage.removeItem(SWEETALERT_PATH_KEY);
                    clearTimeout(swalTimeoutHandle);
                    swalTimeoutHandle = null;
                }
            });
        } else {
            // Suppress HTMX indicator if the path is already being handled
            evt.detail.indicator = null;
        }
    });

    //Add events to close the loader
    document.body.addEventListener('htmx:afterRequest', maybeClose);
    document.body.addEventListener('htmx:responseError', maybeClose);
    document.body.addEventListener('sweetalert:close', closeSweetAlertLoader);

    // Set a flag so we can suppress the loader immediately if navigating via browser history
    document.body.addEventListener('htmx:historyRestore', () => {
        sessionStorage.setItem(SWEETALERT_HISTORY_RESTORED_KEY, 'true');
    });

    window.addEventListener('popstate', () => {
        sessionStorage.setItem(SWEETALERT_HISTORY_RESTORED_KEY, 'true');
    });
}

// Returns the closest element with an indicator attribute
function getIndicatorSource(el) {
    return el.closest('[hx-indicator], [data-hx-indicator]');
}

// Determines the request path, including query string if appropriate
function getRequestPath(detail) {
    const responsePath =
        typeof detail?.pathInfo?.responsePath === 'string'
            ? detail.pathInfo.responsePath
            : (typeof detail?.pathInfo?.path === 'string'
                    ? detail.pathInfo.path
                    : (typeof detail?.path === 'string' ? detail.path : '')
            );

    const elt = detail.elt;

    // If not a form and has an hx-indicator, use the raw path
    if (elt.hasAttribute("hx-indicator") && elt.tagName !== "FORM") {
        return responsePath;
    }

    const isGet = (detail.verb ?? '').toUpperCase() === 'GET';
    const form = elt.closest('form');

    // Append query params for GET form submissions
    if (isGet && form) {
        const params = new URLSearchParams();

        for (const el of form.elements) {
            if (!el.name || el.disabled) continue;

            const type = el.type;
            if ((type === 'checkbox' || type === 'radio') && !el.checked) continue;
            if (type === 'submit') continue;

            params.append(el.name, el.value);
        }

        const queryString = params.toString();
        return queryString ? `${responsePath}?${queryString}` : responsePath;
    }

    return responsePath;
}

// Closes the SweetAlert loader if the path matches
function maybeClose(evt) {
    const activePath = sessionStorage.getItem(SWEETALERT_PATH_KEY);
    const path = getRequestPath(evt.detail);

    if (activePath && path && activePath === path) {
        closeSweetAlertLoader();
    }
}

// Close and clean up SweetAlert loader state
function closeSweetAlertLoader() {
    if (Swal.getPopup()) {
        Swal.close();
        document.dispatchEvent(new CustomEvent('sweetalert:closed'));
        sessionStorage.removeItem(SWEETALERT_PATH_KEY);
        clearTimeout(swalTimeoutHandle);
        swalTimeoutHandle = null;
    }
}
```

Ви налаштовуєте цей (, якщо у вашому `main.js` такий файл

```javascript

import { registerSweetAlertHxIndicator } from './hx-sweetalert-indicator.js';
registerSweetAlertHxIndicator();
```

### Винайти наші елементи

Ви побачите, що я користуюсь `getIndicatorSource` функція, щоб знайти елемент, який викликав запит HTMX. Це важливо, тому що нам потрібно знати, який елемент викликав запрос, так що ми можемо закрити модель, коли він закінчивсяM SK1. Це дуже важливо, бо HT MX має 'приналежність МSK4 тож вам потрібно піднятися на дерево, щоб відшукати елемент, що викликав виклик

```javascript
function getIndicatorSource(el) {
    return el.closest('[hx-indicator], [data-hx-indicator]');
}

```

Тоді на будь-якому запиті HTMX (так `hx-get` або `hx-post`) ви можете використовувати `hx-indicator` атрибут для визначення SweetAlert

Давайте подивимось, як все це працює.

## З 'єднуючи це з ` registerSweetAlertHxIndicator()`

Це функціонує як вхідна точка. Ви бачите, що він підключений до `htmx:configRequest` event. Він активується, коли HTMX збирається зробити прохання

Потім він отримує елемент, який спричинив подію в `evt.detail.elt` і перевіряє, чи є `hx-indicator` атрибут.

Врешті-решт , показує метод SweetAlert2, використовуючи `Swal.fire()`.

```javascript
rt function registerSweetAlertHxIndicator() {
    document.body.addEventListener('htmx:configRequest', function (evt) {
        const trigger = evt.detail.elt;
        const indicatorAttrSource = getIndicatorSource(trigger);
        if (!indicatorAttrSource) return;
        

```

## Дослідження шляху запиту

Якщо це станеться, він отримає шлях запиту, використовуючи `getRequestPath(evt.detail)` і зберігає його в сеансному накопичуванні.
Niw HTMX - це складний бугер, він зберігає шлях в різних місцях залежно від того, де ви знаходитеся у життєвому циклі. Тож в моєму коді я роблю все вищеM SK2 з `detail?.pathInfo?.path ?? detail?.path ?? '';`

Виявляється, що HTMX зберігає *прохання* шлях в `detail.path` і шлях реагування ( для `document.body.addEventListener('htmx:afterRequest', maybeClose); document.body.addEventListener('htmx:responseError', maybeClose);`) в `detail.PathInfo.responsePath` тож нам потрібно надто об 'єднати обидві

Ми також повинні `GET` formularzи;, оскільки їх відповідь, скоріш за все, включає в себе елементи URL, які надходили `<input >` значення, так що відповідь url може бути іншою.

```javascript
// Returns the closest element with an indicator attribute
function getIndicatorSource(el) {
    return el.closest('[hx-indicator], [data-hx-indicator]');
}

// Determines the request path, including query string if appropriate
function getRequestPath(detail) {
    const responsePath =
        typeof detail?.pathInfo?.responsePath === 'string'
            ? detail.pathInfo.responsePath
            : (typeof detail?.pathInfo?.path === 'string'
                    ? detail.pathInfo.path
                    : (typeof detail?.path === 'string' ? detail.path : '')
            );

    const elt = detail.elt;

    // If not a form and has an hx-indicator, use the raw path
    if (elt.hasAttribute("hx-indicator") && elt.tagName !== "FORM") {
        return responsePath;
    }

    const isGet = (detail.verb ?? '').toUpperCase() === 'GET';
    const form = elt.closest('form');

    // Append query params for GET form submissions
    if (isGet && form) {
        const params = new URLSearchParams();

        for (const el of form.elements) {
            if (!el.name || el.disabled) continue;

            const type = el.type;
            if ((type === 'checkbox' || type === 'radio') && !el.checked) continue;
            if (type === 'submit') continue;

            params.append(el.name, el.value);
        }

        const queryString = params.toString();
        return queryString ? `${responsePath}?${queryString}` : responsePath;
    }

    return responsePath;
}
```

NOTA: Це особливо стосується, якщо ви використовуєте `HX-Push-Url` заголовок, щоб змінити URL запиту, який HTMX зберігає для історії.

### Форма

`HttpGet` Форми трохи складні, тому у нас є шматок коду, який виявить, якщо ви `submit` кнопка всередині бланку і додайте параметри строка запиту, викликані тими неприємними вказівками для порівняння з відповіддю URL.

```javascript
const isGet = (detail.verb ?? '').toUpperCase() === 'GET';
    const form = elt.closest('form');

    // Append query params for GET form submissions
    if (isGet && form) {
        const params = new URLSearchParams();

        for (const el of form.elements) {
            if (!el.name || el.disabled) continue;

            const type = el.type;
            if ((type === 'checkbox' || type === 'radio') && !el.checked) continue;
            if (type === 'submit') continue;

            params.append(el.name, el.value);
        }

        const queryString = params.toString();
        return queryString ? `${responsePath}?${queryString}` : responsePath;
    }

    return responsePath;
    ```
    
This is important as HTMX will use the response URL to determine if the request is the same as the previous one. So we need to ensure we have the same URL in both places.

### Extensions
I use this little `Response` extension method to set the `HX-Push-Url` header in my ASP.NET Core app. I also added a second extension which will immediately close the modal (useful if you mess with the request and need to close it immediately). 
```csharp
public static class ResponseExtensions
{
    public static void PushUrl(this HttpResponse response, HttpRequest request)
    {
        response.Headers["HX-Push-Url"] = request.GetEncodedUrl();
    }
}
    public static void CloseSweetAlert(this HttpResponse response)
    {
        response.Headers.Append("HX-Trigger" , JsonSerializer.Serialize(new
        {
            sweetalert = "closed"
        }));

    }
}
```

Ось тут працює другий.:

```javascript
    document.body.addEventListener('sweetalert:close', closeSweetAlertLoader);
```

## Сохранени маршруту

Отже, тепер у нас є шлях, що ми з ним робимоM SK1 Що ж, щоб слідкувати за тим, який запит викликав модедію SweetAlert2, ми зберігаємо його в `sessionStorage` використовуючи `sessionStorage.setItem(SWEETALERT_PATH_KEY, path);`.

( Знову ж таки, ви можете зробити це складнішим і впевнитись, що ви маєте лише один, якщо вам потрібен

## Показування modal

Тоді ми просто покажемо метод SweetAlert2 за допомогою `Swal.fire()`. зверніть увагу, у нас є купа варіантів

Коли він відкривається, перевіряється ключ для зберігання сеансу `SWEETALERT_HISTORY_RESTORED_KEY` що відображається при відновленні історії.. Якщо це так, то ми миттєво зачиняємо модель.

Ми також запускаємо подію `sweetalert:opened` який ви можете використати для будь-якої спеціальної логіки, яка вам потрібна.

```javascript
Swal.fire({
    title: 'Loading...',
    allowOutsideClick: false,
    allowEscapeKey: false,
    showConfirmButton: false,
    theme: 'dark',
    didOpen: () => {
        // Cancel immediately if restored from browser history
        if (sessionStorage.getItem(SWEETALERT_HISTORY_RESTORED_KEY) === 'true') {
            sessionStorage.removeItem(SWEETALERT_HISTORY_RESTORED_KEY);
            Swal.close();
            return;
        }

        Swal.showLoading();
        document.dispatchEvent(new CustomEvent('sweetalert:opened'));

        // Set timeout to auto-close if something hangs
        clearTimeout(swalTimeoutHandle);
        swalTimeoutHandle = setTimeout(() => {
            if (Swal.isVisible()) {
                console.warn('SweetAlert loading modal closed after timeout.');
                closeSweetAlertLoader();
            }
        }, SWEETALERT_TIMEOUT_MS);
    },
    didClose: () => {
        document.dispatchEvent(new CustomEvent('sweetalert:closed'));
        sessionStorage.removeItem(SWEETALERT_PATH_KEY);
        clearTimeout(swalTimeoutHandle);
        swalTimeoutHandle = null;
    }
});
```

Крім того, ми встановили тайм-аут для розв 'язання випадків, коли прохання висувається.. Це важливо, оскільки HTMX не закриває модуля, якщо прохання скасується. `hx-boost`). Це встановлено тут `const SWEETALERT_TIMEOUT_MS = 10000; // Timeout for automatically closing the loader` тож ми можемо закрити моділь, якщо щось йде не так. (itM SK1 я також прийду на консоль

## Закрити його

Отже, тепер ми маємо modal open, нам потрібно закрити його, коли запити закінчуютьсяM SK1 Для цього ми називаємо `maybeClose` функція. Це викликано, коли заява завершена M SK1успішно чи з помилкою
Використовуючи `htmx:afterRequest` і `htmx:responseError` події. Ці події запускаються, як тільки HTMX закінчив запит. `HX-Boost` що може бути трохи смішним щодо того, які події він реагує.)

```javascript
    document.body.addEventListener('htmx:afterRequest', maybeClose);
    document.body.addEventListener('htmx:responseError', maybeClose);
```

```javascript
    function maybeClose(evt) {
        const activePath = sessionStorage.getItem(SWEETALERT_PATH_KEY);
        const path = getRequestPath(evt.detail);

        if (activePath && path && activePath === path) {
            Swal.close();
            sessionStorage.removeItem(SWEETALERT_PATH_KEY);
        }
    }
```

Ви' побачите, що ця функція перевіряє, чи шлях у сеансному накопичуванні є таким же, як і шлях для запиту . Якщо це так M SK2 вона закриває моділь та видаляє шлях з сеансного накопичування .

## Його історія

HTMX має хибний спосіб впорядкування історії, який може дозволити modalу 'stuck' відкрити на зворотній сторінціM SK2 Тому ми додаємо ще декілька подій, щоб ловити це ( більшу частину часу нам потрібна лише одна, аніж пояс.

```javascript
    //Add events to close the loader
    document.body.addEventListener('htmx:afterRequest', maybeClose);
    document.body.addEventListener('htmx:responseError', maybeClose);
    document.body.addEventListener('sweetalert:close', closeSweetAlertLoader);

    // Set a flag so we can suppress the loader immediately if navigating via browser history
    document.body.addEventListener('htmx:historyRestore', () => {
        sessionStorage.setItem(SWEETALERT_HISTORY_RESTORED_KEY, 'true');
    });

    window.addEventListener('popstate', () => {
        sessionStorage.setItem(SWEETALERT_HISTORY_RESTORED_KEY, 'true');
    });`
```

Ви побачите, що ми також встановили `sessionStorage.setItem(SWEETALERT_HISTORY_RESTORED_KEY, 'true');` які ми перевіряємо в `didOpen` події:

```javascript
           didOpen: () => {
    // Cancel immediately if restored from browser history
    if (sessionStorage.getItem(SWEETALERT_HISTORY_RESTORED_KEY) === 'true') {
        sessionStorage.removeItem(SWEETALERT_HISTORY_RESTORED_KEY);
        Swal.close();
        return;
    }
```

Ми робимо це у випадку, коли modal не відкривається `popstate` \ `htmx:historyRestore` ( Особливо, якщо ви маєте велику історію ). Тому нам потрібно перевірити її в `didOpen` подія ( отже, вона є в сеансному ключі , інколи це може перезавантаження і т.д.

# BONUS - Для мого PagingTagHelper

Якщо ви використовуєте мій [ПагуванняTagHelper](https://www.mostlylucid.net/blog/category/PagingTagHelper) є проблема з `PageSize` і використовуючи SweetAlert; це через те, що він ALSO закріплює `  `htmx:configRequest

```javascript
(() => {
    if (window.__pageSizeListenerAdded) return;

    document.addEventListener('htmx:configRequest', event => {
        const { elt } = event.detail;
        if (elt?.matches('[name="pageSize"]')) {
            const params = new URLSearchParams(window.location.search);
            params.set('pageSize', elt.value);

            const paramObj = Object.fromEntries(params.entries());
            event.detail.parameters = paramObj;
            
            const pageSizeEvent = new CustomEvent('pagesize:updated', {
                detail: {
                    params: paramObj,
                    elt,
                },
            });

            document.dispatchEvent(pageSizeEvent);
        }
    });

    window.__pageSizeListenerAdded = true;
})();
```

Щоб виправити це, вам потрібно додати маленьку функцію:

```javascript
/**
 * Appends the current pageSize from the browser's URL to the HTMX request path,
 * modifying event.detail.path directly.
 *
 * @param {CustomEvent['detail']} detail - The HTMX event.detail object
 */
export function getPathWithPageSize(detail) {
    const originalPath = detail.path;
    if (!originalPath) return null;

    const selectedValue = detail.elt?.value ?? '';
    const url = new URL(originalPath, window.location.origin);

    // Use the current location's query string, update pageSize
    const locationParams = new URLSearchParams(window.location.search);
    locationParams.set('pageSize', selectedValue);
    url.search = locationParams.toString();

    return url.pathname + url.search;
}
```

Це просто отримує запрошення і додає `pagesize` параметр до нього. Тоді ввести цю функцію

```javascript
import { getPathWithPageSize } from './pagesize-sweetalert'

export function registerSweetAlertHxIndicator() {
    document.body.addEventListener('htmx:configRequest', function (evt) {
        const trigger = evt.detail.elt;

        const indicatorAttrSource = getIndicatorSource(trigger);
        if (!indicatorAttrSource) return;

        // ✅ If this is a pageSize-triggered request, use our custom path
        let path;
        if (evt.detail.headers?.['HX-Trigger-Name'] === 'pageSize') {
            path = getPathWithPageSize(evt.detail);
            console.debug('[SweetAlert] Using custom path with updated pageSize:', path);
        } else {
            path = getRequestPath(evt.detail);
        }
        ...rest of code

```

Ви бачите, що ми виявляємо `pageSize` триггер і коли він знаходить його ( то ви змінили розмір сторінки ) він використовує `getPathWithPageSize` функція, щоб отримати новий шлях. `pageSize` код замінить це пізніше в ланцюзі, але це дозволить його правильно виявити, тож він закривається, як очікувалося.

# На завершення

Таким чином, як ви можете використовувати SweetAlert, як індикатор завантаження HTMX? МSK2 Це трохи хитро, але це працює. МSK4 - хороший спосіб використовувати ту ж саму бібліотеку для both loading indicators and confirmation dialogs