htmx のイベントフックを使いこなす実践テクニック

2025年7月7日

htmx

モダンな Web アプリケーション開発において、ユーザー体験の向上は開発者にとって永遠のテーマです。htmx は軽量でありながら強力なライブラリとして注目されていますが、その真の力を引き出すためにはイベントフックの理解が欠かせません。

本記事では、htmx のイベントフックを使いこなすための実践的なテクニックをご紹介します。初心者の方でも安心して学べるよう、基礎から応用まで体系的に解説していきますね。きっと、あなたの Web アプリケーション開発に新たな可能性をもたらすでしょう。

背景

htmx におけるイベントフックの役割

htmx は「HTML over the wire」という思想のもと、JavaScript を書くことなくリッチな Web アプリケーションを構築できる革新的なライブラリです。しかし、実際の開発現場では、デフォルトの動作だけでは対応できない場面が必ず訪れます。

そこで活躍するのがイベントフックです。イベントフックは、htmx の処理の各段階で実行されるカスタムロジックを挿入する仕組みで、まさに「魔法の杖」のような存在なのです。

従来の JavaScript イベント処理との違い

従来の JavaScript では、DOM 要素にイベントリスナーを直接アタッチして処理を行っていました。しかし、htmx のイベントフックはライフサイクル全体を通じた統一的なアプローチを提供します。

#	従来のアプローチ	htmx イベントフック
1	DOM 操作が分散しがち	統一的なライフサイクル管理
2	イベント管理が複雑	宣言的で分かりやすい
3	デバッグが困難	段階的な処理追跡が可能

モダン Web 開発でのイベントフック活用の重要性

現代の Web アプリケーションでは、ユーザーがストレスを感じることなく操作できることが求められます。ローディング状態の表示、エラーハンドリング、リアルタイムなフィードバック——これらすべてを美しく実装するためには、イベントフックの力が不可欠です。

私自身も多くのプロジェクトで実感していることですが、イベントフックを適切に活用することで、ユーザー満足度が大幅に向上するのです。

課題

htmx のデフォルト動作だけでは対応できない複雑な要件

htmx の基本機能は非常に強力ですが、以下のような場面では限界があります。

複雑なフォームバリデーション リアルタイムでのバリデーション結果表示や、複数フィールドの相関チェックなど、高度な要件には追加の制御が必要です。

動的な UI 変更 レスポンス内容に応じてページ全体のレイアウトを変更したり、アニメーションを適用したりする場合、デフォルトの swap 処理では不十分です。

ユーザー体験向上のためのカスタマイズニーズ

現代のユーザーは、アプリケーションに対して高い期待を持っています。

「ボタンを押した瞬間から何かが起こっている感覚」
「エラーが発生してもパニックにならない親切なメッセージ」
「待ち時間を感じさせない滑らかな操作感」

これらの期待に応えるためには、きめ細やかな制御が必要になります。

エラーハンドリングとローディング状態管理の必要性

Web アプリケーションでは、予期しないエラーが発生することは避けられません。以下のようなエラーが典型的です：

typescript// よく遭遇するエラー例
Error: Request failed with status code 500
TypeError: Cannot read property 'data' of null
NetworkError: Failed to fetch

こうしたエラーに対して、ユーザーに優しい体験を提供することが開発者の使命です。

解決策

htmx イベントフックの基本概念

htmx のイベントフックは、リクエスト・レスポンスのライフサイクルの各段階で実行されるコールバック関数です。これにより、プロセスの任意の時点でカスタムロジックを挿入できます。

javascript// 基本的なイベントフック登録の形
document.addEventListener(
  'htmx:eventName',
  function (event) {
    // カスタムロジックをここに記述
    console.log('イベントが発火されました:', event.detail);
  }
);

この仕組みにより、開発者は非侵入的でありながら強力なカスタマイズを実現できるのです。

主要イベントフック一覧と使い分け

htmx のイベントフックは大きく 3 つのカテゴリに分類されます。それぞれの特徴と使用場面を理解することが重要です。

#	カテゴリ	主なイベント	使用場面
1	リクエスト系	beforeRequest, afterRequest	API 呼び出し制御
2	レスポンス系	beforeSwap, afterSwap	DOM 更新制御
3	ライフサイクル系	load, pushedIntoHistory	ページ遷移制御

イベントフック実装のベストプラクティス

成功するイベントフック実装のためには、以下の原則を守ることが大切です：

1. 責任の分離 各イベントフックには明確な責任を持たせ、複数の処理を一つのフックに詰め込まないようにします。

2. エラーハンドリングの徹底 イベントフック内でエラーが発生しても、アプリケーション全体が停止しないよう適切な例外処理を行います。

3. パフォーマンスの配慮 重い処理は非同期で実行し、ユーザーの操作をブロックしないよう注意します。

具体例

リクエスト系フック: beforeRequest, configRequest, afterRequest

リクエスト系フックは、サーバーとの通信プロセスを制御する強力な仕組みです。これらを組み合わせることで、洗練されたユーザー体験を提供できます。

beforeRequest でローディング状態を表示

ユーザーがボタンを押した瞬間から、「何かが起こっている」ことを伝えることは非常に重要です。

javascript// ローディング状態の表示とボタンの無効化
document.addEventListener(
  'htmx:beforeRequest',
  function (event) {
    const trigger = event.detail.elt;

    // ボタンの場合はローディング状態に変更
    if (trigger.tagName === 'BUTTON') {
      trigger.disabled = true;
      trigger.innerHTML = `
            <span class="spinner"></span>
            処理中...
        `;
      trigger.classList.add('loading');
    }

    // グローバルローディングインジケーターを表示
    const loader = document.getElementById('global-loader');
    if (loader) {
      loader.style.display = 'block';
    }
  }
);

このコードにより、ユーザーは「何かが起こっている」ことを即座に理解できます。心理学的にも、フィードバックの速さは満足度に直結するのです。

configRequest でリクエストをカスタマイズ

API 認証やヘッダーの追加など、リクエストの詳細をカスタマイズする場面は多いものです。

javascript// 認証トークンの自動付与とリクエストログ
document.addEventListener(
  'htmx:configRequest',
  function (event) {
    const config = event.detail;

    // JWTトークンを自動的に付与
    const token = localStorage.getItem('authToken');
    if (token) {
      config.headers['Authorization'] = `Bearer ${token}`;
    }

    // リクエストサイズ制限チェック
    if (
      config.parameters &&
      JSON.stringify(config.parameters).length > 50000
    ) {
      event.preventDefault();
      showError(
        '送信データが大きすぎます。ファイルサイズを確認してください。'
      );
      return;
    }

    // 開発環境でのリクエストログ
    if (process.env.NODE_ENV === 'development') {
      console.log('🚀 HTMX Request:', {
        verb: config.verb,
        path: config.path,
        headers: config.headers,
        parameters: config.parameters,
      });
    }
  }
);

afterRequest で後処理を実行

リクエスト完了後の処理により、ユーザー体験の仕上げを行います。

javascript// リクエスト完了後のクリーンアップと統計収集
document.addEventListener(
  'htmx:afterRequest',
  function (event) {
    const trigger = event.detail.elt;
    const xhr = event.detail.xhr;

    // ローディング状態の解除
    if (trigger.tagName === 'BUTTON') {
      trigger.disabled = false;
      trigger.classList.remove('loading');

      // 成功時と失敗時で異なる表示
      if (xhr.status >= 200 && xhr.status < 300) {
        trigger.innerHTML = '✓ 完了';
        setTimeout(() => {
          trigger.innerHTML =
            trigger.dataset.originalText || '送信';
        }, 2000);
      } else {
        trigger.innerHTML = '⚠ エラー';
        trigger.classList.add('error');
      }
    }

    // グローバルローディングを非表示
    const loader = document.getElementById('global-loader');
    if (loader) {
      loader.style.display = 'none';
    }
  }
);

レスポンス系フック: beforeSwap, afterSwap, responseError

レスポンス系フックは、サーバーからの応答を処理し、DOM を更新する際の制御を担います。

beforeSwap でレスポンス内容を検証・加工

サーバーからのレスポンスを受け取った直後、DOM に反映する前の段階で様々な処理を行えます。

javascript// レスポンス検証とセキュリティチェック
document.addEventListener(
  'htmx:beforeSwap',
  function (event) {
    const response = event.detail.xhr.responseText;
    const serverResponse = event.detail.serverResponse;

    try {
      // JSONレスポンスの場合の特別処理
      if (response.startsWith('{')) {
        const data = JSON.parse(response);

        // エラーメッセージの特別処理
        if (data.error) {
          event.preventDefault();
          showNotification(data.error, 'error');
          return;
        }

        // 成功メッセージの表示
        if (data.message) {
          showNotification(data.message, 'success');
        }

        // HTMLコンテンツがある場合のみswap実行
        if (data.html) {
          event.detail.serverResponse = data.html;
        } else {
          event.preventDefault();
          return;
        }
      }

      // XSSプロテクション: 危険なスクリプトタグをチェック
      if (
        response.includes('<script>') &&
        !response.includes('<!-- trusted -->')
      ) {
        console.warn(
          '⚠️ 潜在的に危険なスクリプトが検出されました'
        );
        event.preventDefault();
        return;
      }
    } catch (e) {
      console.error('レスポンス処理エラー:', e);
      event.preventDefault();
      showError('レスポンスの処理中にエラーが発生しました');
    }
  }
);

afterSwap で DOM 更新後の処理

DOM 更新完了後は、新しい要素に対する初期化処理を行う絶好のタイミングです。

javascript// 新しい要素の初期化とアクセシビリティ対応
document.addEventListener(
  'htmx:afterSwap',
  function (event) {
    const swappedElement = event.detail.target;

    // 新しく追加されたフォーム要素の初期化
    const newForms = swappedElement.querySelectorAll(
      'form[data-validation]'
    );
    newForms.forEach((form) => {
      initializeFormValidation(form);
    });

    // ツールチップの再初期化
    const tooltips = swappedElement.querySelectorAll(
      '[data-tooltip]'
    );
    tooltips.forEach((element) => {
      new Tooltip(element);
    });

    // アクセシビリティ: スクリーンリーダー向けの通知
    if (swappedElement.dataset.announceChange) {
      const announcement =
        swappedElement.dataset.announceChange;
      announceToScreenReader(announcement);
    }

    // アニメーション効果
    swappedElement.style.opacity = '0';
    swappedElement.style.transform = 'translateY(20px)';

    requestAnimationFrame(() => {
      swappedElement.style.transition = 'all 0.3s ease';
      swappedElement.style.opacity = '1';
      swappedElement.style.transform = 'translateY(0)';
    });
  }
);

// スクリーンリーダー向けの通知関数
function announceToScreenReader(message) {
  const announcer = document.createElement('div');
  announcer.setAttribute('aria-live', 'polite');
  announcer.setAttribute('aria-atomic', 'true');
  announcer.style.position = 'absolute';
  announcer.style.left = '-10000px';
  announcer.textContent = message;

  document.body.appendChild(announcer);
  setTimeout(
    () => document.body.removeChild(announcer),
    1000
  );
}

responseError で優雅なエラーハンドリング

エラーが発生した時こそ、ユーザーへの思いやりが試される瞬間です。

javascript// 包括的なエラーハンドリング
document.addEventListener(
  'htmx:responseError',
  function (event) {
    const xhr = event.detail.xhr;
    const trigger = event.detail.elt;

    // ステータスコードに応じた詳細なエラーハンドリング
    let errorMessage = '';
    let errorType = 'error';

    switch (xhr.status) {
      case 400:
        errorMessage =
          '入力内容に誤りがあります。もう一度ご確認ください。';
        errorType = 'warning';
        highlightInvalidFields(trigger);
        break;
      case 401:
        errorMessage =
          'ログインが必要です。ページを更新してログインし直してください。';
        setTimeout(() => window.location.reload(), 3000);
        break;
      case 403:
        errorMessage =
          'この操作を実行する権限がありません。';
        break;
      case 404:
        errorMessage =
          '指定されたページまたはリソースが見つかりません。';
        break;
      case 422:
        // サーバーサイドバリデーションエラー
        try {
          const errorData = JSON.parse(xhr.responseText);
          if (errorData.errors) {
            displayValidationErrors(
              errorData.errors,
              trigger
            );
            return;
          }
        } catch (e) {
          errorMessage = '入力内容に問題があります。';
        }
        break;
      case 429:
        errorMessage =
          'リクエストが多すぎます。しばらく待ってから再試行してください。';
        break;
      case 500:
        errorMessage =
          'サーバーエラーが発生しました。しばらく待ってから再試行してください。';
        break;
      case 502:
      case 503:
      case 504:
        errorMessage =
          'サーバーが一時的に利用できません。しばらく待ってから再試行してください。';
        break;
      default:
        errorMessage = `予期しないエラーが発生しました (ステータス: ${xhr.status})`;
    }

    // エラー表示
    showNotification(errorMessage, errorType);

    // エラーログの送信（本番環境のみ）
    if (process.env.NODE_ENV === 'production') {
      logErrorToServer({
        status: xhr.status,
        url: xhr.responseURL,
        trigger: trigger.tagName,
        timestamp: new Date().toISOString(),
      });
    }
  }
);

ライフサイクル系フック: load, pushedIntoHistory

ページの読み込みと履歴管理に関するフックは、SPA 的な体験を提供する上で重要な役割を果たします。

load イベントで初期化処理

ページやコンテンツが読み込まれた際の初期化処理を統一的に管理できます。

javascript// ページ読み込み時の統一初期化処理
document.addEventListener('htmx:load', function (event) {
  const loadedElement = event.detail.elt;

  // プログレッシブエンハンスメント: JavaScriptが利用可能な場合の拡張
  loadedElement.classList.add('js-enabled');

  // 遅延読み込み画像の処理
  const lazyImages = loadedElement.querySelectorAll(
    'img[data-lazy]'
  );
  if (
    lazyImages.length > 0 &&
    'IntersectionObserver' in window
  ) {
    const imageObserver = new IntersectionObserver(
      (entries) => {
        entries.forEach((entry) => {
          if (entry.isIntersecting) {
            const img = entry.target;
            img.src = img.dataset.lazy;
            img.classList.add('lazy-loaded');
            imageObserver.unobserve(img);
          }
        });
      }
    );

    lazyImages.forEach((img) => imageObserver.observe(img));
  }

  // カスタム要素の初期化
  const customElements = loadedElement.querySelectorAll(
    '[data-component]'
  );
  customElements.forEach((element) => {
    const componentName = element.dataset.component;
    if (
      window.Components &&
      window.Components[componentName]
    ) {
      new window.Components[componentName](element);
    }
  });

  // アナリティクス: ページビューの追跡
  if (typeof gtag !== 'undefined') {
    gtag('config', 'GA_TRACKING_ID', {
      page_path: window.location.pathname,
    });
  }
});

履歴管理でブラウザバック対応

ブラウザの戻るボタンが押された時の適切な処理により、ユーザーの期待通りの動作を実現します。

javascript// 履歴管理とブラウザバック対応
document.addEventListener(
  'htmx:pushedIntoHistory',
  function (event) {
    const path = event.detail.path;

    // ページタイトルの動的更新
    const titleElement = document.querySelector('title');
    const h1Element = document.querySelector('h1');

    if (h1Element && titleElement) {
      const newTitle = `${h1Element.textContent} | MyApp`;
      titleElement.textContent = newTitle;
    }

    // ナビゲーション状態の更新
    updateNavigationState(path);

    // ページ固有のメタデータ更新
    updateMetaTags(path);
  }
);

document.addEventListener(
  'htmx:poppedIntoHistory',
  function (event) {
    // ブラウザバック時の特別処理
    const path = event.detail.path;

    // 状態の復元
    restorePageState(path);

    // スクロール位置の復元
    if (
      event.detail.state &&
      event.detail.state.scrollPosition
    ) {
      window.scrollTo(0, event.detail.state.scrollPosition);
    }
  }
);

// ナビゲーション状態更新関数
function updateNavigationState(currentPath) {
  const navLinks = document.querySelectorAll('nav a[href]');
  navLinks.forEach((link) => {
    link.classList.remove('active');
    if (link.getAttribute('href') === currentPath) {
      link.classList.add('active');
    }
  });
}

実践的な組み合わせパターン

実際のプロジェクトでは、複数のイベントフックを組み合わせて使用することが多くなります。ここでは、よく使われるパターンをご紹介します。

パターン 1: フォーム送信の完全制御

javascript// フォーム送信の完全制御システム
class FormController {
  constructor() {
    this.initializeFormHandling();
  }

  initializeFormHandling() {
    // 送信前: バリデーションとローディング
    document.addEventListener(
      'htmx:beforeRequest',
      (event) => {
        if (event.detail.elt.tagName === 'FORM') {
          this.handleFormBeforeRequest(event);
        }
      }
    );

    // 設定: CSRFトークンの自動付与
    document.addEventListener(
      'htmx:configRequest',
      (event) => {
        if (event.detail.elt.tagName === 'FORM') {
          this.addCSRFToken(event);
        }
      }
    );

    // 成功: 結果表示とリダイレクト
    document.addEventListener('htmx:afterSwap', (event) => {
      if (event.detail.xhr.status === 200) {
        this.handleFormSuccess(event);
      }
    });

    // エラー: 詳細なエラー表示
    document.addEventListener(
      'htmx:responseError',
      (event) => {
        if (event.detail.elt.tagName === 'FORM') {
          this.handleFormError(event);
        }
      }
    );
  }

  handleFormBeforeRequest(event) {
    const form = event.detail.elt;

    // フォームバリデーション
    if (!this.validateForm(form)) {
      event.preventDefault();
      return;
    }

    // 送信ボタンの無効化
    const submitButton = form.querySelector(
      '[type="submit"]'
    );
    if (submitButton) {
      submitButton.disabled = true;
      submitButton.dataset.originalText =
        submitButton.textContent;
      submitButton.innerHTML = `
                <span class="spinner"></span>
                送信中...
            `;
    }

    // エラー表示のクリア
    this.clearFormErrors(form);
  }

  validateForm(form) {
    let isValid = true;
    const requiredFields =
      form.querySelectorAll('[required]');

    requiredFields.forEach((field) => {
      if (!field.value.trim()) {
        this.showFieldError(field, 'この項目は必須です');
        isValid = false;
      }
    });

    // メールアドレスの形式チェック
    const emailFields = form.querySelectorAll(
      'input[type="email"]'
    );
    emailFields.forEach((field) => {
      if (field.value && !this.isValidEmail(field.value)) {
        this.showFieldError(
          field,
          '正しいメールアドレスを入力してください'
        );
        isValid = false;
      }
    });

    return isValid;
  }

  addCSRFToken(event) {
    const csrfToken = document.querySelector(
      'meta[name="csrf-token"]'
    );
    if (csrfToken) {
      event.detail.headers['X-CSRF-TOKEN'] =
        csrfToken.content;
    }
  }

  handleFormSuccess(event) {
    const form = event.detail.elt;

    // 成功メッセージの表示
    showNotification('正常に送信されました', 'success');

    // フォームのリセット（必要に応じて）
    if (form.dataset.resetOnSuccess) {
      form.reset();
    }

    // リダイレクト処理
    const redirectUrl =
      event.detail.xhr.getResponseHeader('X-Redirect');
    if (redirectUrl) {
      setTimeout(() => {
        window.location.href = redirectUrl;
      }, 1500);
    }
  }

  handleFormError(event) {
    const xhr = event.detail.xhr;
    const form = event.detail.elt;

    try {
      const errorResponse = JSON.parse(xhr.responseText);

      if (errorResponse.field_errors) {
        // フィールド別エラーの表示
        Object.entries(errorResponse.field_errors).forEach(
          ([field, errors]) => {
            const fieldElement = form.querySelector(
              `[name="${field}"]`
            );
            if (fieldElement) {
              this.showFieldError(fieldElement, errors[0]);
            }
          }
        );
      } else if (errorResponse.message) {
        showNotification(errorResponse.message, 'error');
      }
    } catch (e) {
      showNotification(
        '送信中にエラーが発生しました',
        'error'
      );
    }

    // 送信ボタンの復元
    const submitButton = form.querySelector(
      '[type="submit"]'
    );
    if (submitButton) {
      submitButton.disabled = false;
      submitButton.textContent =
        submitButton.dataset.originalText || '送信';
    }
  }

  isValidEmail(email) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return emailRegex.test(email);
  }

  showFieldError(field, message) {
    field.classList.add('error');

    // 既存のエラーメッセージを削除
    const existingError =
      field.parentNode.querySelector('.field-error');
    if (existingError) {
      existingError.remove();
    }

    // 新しいエラーメッセージを追加
    const errorElement = document.createElement('div');
    errorElement.className = 'field-error';
    errorElement.textContent = message;
    field.parentNode.appendChild(errorElement);
  }

  clearFormErrors(form) {
    const errorFields = form.querySelectorAll('.error');
    errorFields.forEach((field) =>
      field.classList.remove('error')
    );

    const errorMessages =
      form.querySelectorAll('.field-error');
    errorMessages.forEach((message) => message.remove());
  }
}

// フォームコントローラーの初期化
document.addEventListener('DOMContentLoaded', () => {
  new FormController();
});

パターン 2: 動的コンテンツローディングシステム

javascript// 動的コンテンツローディングシステム
class ContentLoader {
  constructor() {
    this.loadingElements = new Set();
    this.initializeLoader();
  }

  initializeLoader() {
    // ローディング開始
    document.addEventListener(
      'htmx:beforeRequest',
      (event) => {
        this.showLoading(event.detail.elt);
      }
    );

    // ローディング完了
    document.addEventListener(
      'htmx:afterRequest',
      (event) => {
        this.hideLoading(event.detail.elt);
      }
    );

    // コンテンツ更新後の処理
    document.addEventListener('htmx:afterSwap', (event) => {
      this.initializeNewContent(event.detail.target);
    });

    // エラー時のフォールバック
    document.addEventListener(
      'htmx:responseError',
      (event) => {
        this.showErrorFallback(event.detail.elt);
      }
    );
  }

  showLoading(element) {
    // 要素固有のローディング表示
    const loadingOverlay = this.createLoadingOverlay();
    element.style.position = 'relative';
    element.appendChild(loadingOverlay);

    this.loadingElements.add(element);

    // プログレスバーの表示
    this.updateGlobalProgress();
  }

  hideLoading(element) {
    const overlay = element.querySelector(
      '.loading-overlay'
    );
    if (overlay) {
      overlay.remove();
    }

    this.loadingElements.delete(element);
    this.updateGlobalProgress();
  }

  createLoadingOverlay() {
    const overlay = document.createElement('div');
    overlay.className = 'loading-overlay';
    overlay.innerHTML = `
            <div class="loading-spinner">
                <div class="spinner"></div>
                <p>読み込み中...</p>
            </div>
        `;
    return overlay;
  }

  updateGlobalProgress() {
    const progressBar = document.getElementById(
      'global-progress'
    );
    if (!progressBar) return;

    if (this.loadingElements.size > 0) {
      progressBar.style.display = 'block';
      progressBar.style.opacity = '1';
    } else {
      progressBar.style.opacity = '0';
      setTimeout(() => {
        progressBar.style.display = 'none';
      }, 300);
    }
  }

  initializeNewContent(target) {
    // 新しく追加された画像の遅延読み込み
    this.initializeLazyImages(target);

    // インタラクティブ要素の初期化
    this.initializeInteractiveElements(target);

    // カウンターアニメーション
    this.animateCounters(target);
  }

  initializeLazyImages(container) {
    const images =
      container.querySelectorAll('img[data-src]');

    if ('IntersectionObserver' in window) {
      const imageObserver = new IntersectionObserver(
        (entries) => {
          entries.forEach((entry) => {
            if (entry.isIntersecting) {
              const img = entry.target;
              img.src = img.dataset.src;
              img.classList.add('loaded');
              imageObserver.unobserve(img);
            }
          });
        }
      );

      images.forEach((img) => imageObserver.observe(img));
    }
  }

  animateCounters(container) {
    const counters = container.querySelectorAll(
      '[data-counter]'
    );

    counters.forEach((counter) => {
      const target = parseInt(counter.dataset.counter);
      const duration =
        parseInt(counter.dataset.duration) || 2000;

      this.animateNumber(counter, 0, target, duration);
    });
  }

  animateNumber(element, start, end, duration) {
    const startTime = performance.now();

    function update(currentTime) {
      const elapsed = currentTime - startTime;
      const progress = Math.min(elapsed / duration, 1);

      const current = Math.floor(
        start + (end - start) * progress
      );
      element.textContent = current.toLocaleString();

      if (progress < 1) {
        requestAnimationFrame(update);
      }
    }

    requestAnimationFrame(update);
  }

  showErrorFallback(element) {
    const errorMessage = document.createElement('div');
    errorMessage.className = 'error-fallback';
    errorMessage.innerHTML = `
            <div class="error-content">
                <h3>読み込みに失敗しました</h3>
                <p>しばらく待ってから再試行してください</p>
                <button onclick="location.reload()">ページを更新</button>
            </div>
        `;

    // 既存のコンテンツを置換
    element.innerHTML = '';
    element.appendChild(errorMessage);
  }
}

// コンテンツローダーの初期化
document.addEventListener('DOMContentLoaded', () => {
  new ContentLoader();
});