UX SweetAlert

https://github.com/pentiminax/ux-sweet-alert
Admin
UX SweetAlert is a Symfony bundle that integrates the SweetAlert2 library into Symfony applications,...
Tokens:15,163
Snippets:182
Trust Score:9.6
License:MIT
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install PHP dependencies

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/AGENTS.md

Command to install project dependencies via Composer.

```bash
composer install
```

--------------------------------

### Install the bundle via Composer

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/getting-started/installation.mdx

Run this command to add the package to your Symfony project.

```bash
composer require pentiminax/ux-sweet-alert
```

--------------------------------

### Verify installation with a controller action

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/getting-started/installation.mdx

Queue a success alert in a controller to verify that the bundle is correctly configured and rendering.

```php
use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

final class DashboardController extends AbstractController
{
    #[Route('/dashboard', name: 'app_dashboard')]
    public function __invoke(AlertManagerInterface $alertManager): Response
    {
        $alertManager->success(
            title: 'Installed',
            text: 'UX SweetAlert is ready to render.'
        );

        return $this->render('dashboard/index.html.twig');
    }
}
```

--------------------------------

### Install Webpack Encore dependencies

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/getting-started/installation.mdx

Use these commands to install JavaScript dependencies and rebuild assets when using Webpack Encore.

```bash
npm install --force
npm run watch
```

--------------------------------

### Controller Alert Integration

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/integrations/turbo.mdx

Example of using AlertManagerInterface within a controller to trigger alerts in JSON responses.

```php
use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Symfony\Component\HttpFoundation\JsonResponse;

public function __invoke(AlertManagerInterface $alertManager): JsonResponse
{
    $alertManager->info(
        title: 'Background sync finished',
        text: 'Your cache is fresh again.'
    );

    return $this->json(['status' => 'ok']);
}
```

--------------------------------

### Automatic HTMX Trigger Header

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/integrations/htmx.mdx

This header is automatically dispatched by the response listener when Turbo is not installed. It contains the first queued alert serialized under the `ux-sweet-alert:alert:added` event name.

```http
HX-Trigger: {"ux-sweet-alert:alert:added":{"alert":{"title":"Saved","icon":"success"}}}
```

--------------------------------

### Run the test suite

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/AGENTS.md

Command to execute the PHPUnit test suite.

```bash
./vendor/bin/phpunit
```

--------------------------------

### Run static analysis

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/AGENTS.md

Command to perform static analysis on source and test files using PHPStan.

```bash
./vendor/bin/phpstan analyse src tests
```

--------------------------------

### Manual Alert Creation

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/reference/alert-manager-and-alert-object.mdx

How to manually create an Alert object.

```APIDOC
## Manual Alert Creation

### Description
Methods for creating standalone `Alert` objects.

### Methods
- **Alert::new()**: Creates a standalone alert with an optional icon, position, and custom class array.
- **Alert::withDefaults()**: Used internally by the manager to apply bundle defaults.
```

--------------------------------

### Create and Customize a Warning Alert

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/guide/alerts.mdx

Use the `warning()` helper to create an alert and fluently chain customization methods like adding cancel and deny buttons.

```php
$alert = $alertManager->warning(
    title: 'Danger zone',
    text: 'This action cannot be undone.'
);

$alert
    ->withCancelButton()
    ->withDenyButton()
    ->denyOutsideClick()
    ->denyEscapeKey();
```

--------------------------------

### Create a Custom Alert Instance

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/guide/alerts.mdx

Manually create an `Alert` instance using `Alert::new()` for direct control over its lifecycle. This method allows specifying icon, position, and rich content.

```php
use Pentiminax\UX\SweetAlert\Enum\Icon;
use Pentiminax\UX\SweetAlert\Enum\Position;
use Pentiminax\UX\SweetAlert\Model\Alert;

$alert = Alert::new(
    title: 'Custom alert',
    text: 'Created manually.',
    icon: Icon::INFO,
    position: Position::TOP
)
    ->html('<strong>Rich content</strong>')
    ->setFooter('Need help? Contact support.');

$alertManager->addAlert($alert);
```

--------------------------------

### Create an Input Dialog with Select Field

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

The `input` method with `Select` allows users to choose from a predefined list of options. Define the options, label, and default value.

```php
<?php

namespace App\Controller;

use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Pentiminax\UX\SweetAlert\InputType\Select;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;

class InviteController extends AbstractController
{
    #[Route('/team/invite', name: 'app_team_invite')]
    public function invite(AlertManagerInterface $alertManager): Response
    {
        $alertManager->input(
            inputType: new Select(
                options: [
                    'admin' => 'Administrator',
                    'editor' => 'Editor',
                    'viewer' => 'Viewer',
                ],
                label: 'Role',
                value: 'viewer'
            ),
            title: 'Invite Team Member',
            text: 'Select the role for the new member.',
            callback: $this->generateUrl(
                'app_team_invite_save',
                referenceType: UrlGeneratorInterface::ABSOLUTE_URL
            )
        );

        return $this->render('team/invite.html.twig');
    }
}
```

--------------------------------

### Create Info Alert

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Displays an informational alert with a blue info icon.

```php
<?php

namespace App\Controller;

use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\Routing\Attribute\Route;

class SyncController extends AbstractController
{
    #[Route('/api/sync', name: 'app_sync')]
    public function sync(AlertManagerInterface $alertManager): JsonResponse
    {
        // Sync logic...

        $alertManager->info(
            title: 'Background Sync Finished',
            text: 'Your cache is fresh again.'
        );

        return $this->json(['status' => 'ok']);
    }
}
```

--------------------------------

### Create a Question Alert

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Use the `question` method to create a confirmation dialog with custom button texts. This is suitable for actions that require user confirmation.

```php
<?php

namespace App\Controller;

use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class ConversationController extends AbstractController
{
    #[Route('/conversation/{id}/archive', name: 'app_conversation_archive')]
    public function archive(int $id, AlertManagerInterface $alertManager): Response
    {
        $alertManager->question(
            title: 'Archive Conversation?',
            text: 'This action cannot be undone.'
        )
            ->withCancelButton()
            ->withDenyButton()
            ->confirmButtonText('Archive')
            ->cancelButtonText('Keep it')
            ->setDenyButtonText('Delete instead');

        return $this->render('conversation/archive.html.twig', ['id' => $id]);
    }
}
```

--------------------------------

### Create Textarea Input Dialog

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Use this to create a dialog for multi-line text input. Specify label, placeholder, and input attributes like rows.

```php
<?php

namespace App\Controller;

use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Pentiminax\UX\SweetAlert\InputType\Textarea;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class FeedbackController extends AbstractController
{
    #[Route('/feedback', name: 'app_feedback')]
    public function feedback(AlertManagerInterface $alertManager): Response
    {
        $alertManager->input(
            inputType: new Textarea(
                label: 'Your Feedback',
                placeholder: 'Tell us what you think...',
                inputAttributes: ['rows' => '5']
            ),
            title: 'Submit Feedback',
            text: 'We appreciate your input.'
        )
            ->withCancelButton()
            ->confirmButtonText('Submit');

        return $this->render('feedback/index.html.twig');
    }
}
```

--------------------------------

### AlertManagerInterface::question()

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Creates a confirmation dialog with a blue question mark icon.

```APIDOC
## AlertManagerInterface::question()

### Description
Creates a question alert with a blue question mark icon, typically used for confirmation dialogs.

### Parameters
- **title** (string) - Required - The title of the alert.
- **text** (string) - Required - The body text of the alert.
```

--------------------------------

### Create Range Input Dialog

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Use this to create a dialog with a numeric slider for value selection within a defined range. Configure label, default value, min, max, and step.

```php
<?php

namespace App\Controller;

use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Pentiminax\UX\SweetAlert\InputType\Range;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class VolumeController extends AbstractController
{
    #[Route('/settings/volume', name: 'app_volume')]
    public function volume(AlertManagerInterface $alertManager): Response
    {
        $alertManager->input(
            inputType: new Range(
                label: 'Volume Level',
                value: '50',
                min: 0,
                max: 100,
                step: 5
            ),
            title: 'Adjust Volume'
        );

        return $this->render('settings/volume.html.twig');
    }
}
```

--------------------------------

### Create Input Dialogs

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/README.md

Use the input method with specific input type classes to collect user data.

```php
use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Pentiminax\UX\SweetAlert\InputType\Text;

#[Route('/profile', name: 'app_profile')]
public function index(AlertManagerInterface $alertManager): Response
{
    $alertManager->input(
        inputType: new Text(
            label: 'Display name',
            value: 'Tanguy',
            placeholder: 'Enter your display name',
        ),
        title: 'Update profile',
        text: 'This change is visible to other users.'
    );

    return $this->render('profile/index.html.twig');
}
```

--------------------------------

### Applying Theme to Toast

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/guide/toasts.mdx

Customize the appearance of a toast notification by applying a theme. Ensure the Theme enum is imported.

```php
use Pentiminax\UX\SweetAlert\Enum\Theme;

$toast = $alertManager->toast(title: 'Saved');
$toast->theme(Theme::MaterialUILight);
```

--------------------------------

### Create an Input Dialog with Text Field

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Use the `input` method with `Text` to prompt the user for text input. Configure labels, placeholders, and validation messages.

```php
<?php

namespace App\Controller;

use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Pentiminax\UX\SweetAlert\InputType\Text;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;

class DisplayNameController extends AbstractController
{
    #[Route('/profile/display-name', name: 'app_display_name')]
    public function edit(AlertManagerInterface $alertManager): Response
    {
        $alertManager->input(
            inputType: new Text(
                label: 'Display Name',
                value: 'Tanguy',
                placeholder: 'Enter your public display name',
                inputAttributes: ['maxlength' => '40']
            ),
            title: 'Update Profile',
            text: 'This change is visible to other users.',
            callback: $this->generateUrl(
                'app_display_name_save',
                referenceType: UrlGeneratorInterface::ABSOLUTE_URL
            )
        )
            ->validationMessage('A display name is required.')
            ->withCancelButton();

        return $this->render('profile/display_name.html.twig');
    }
}
```

--------------------------------

### Create File Upload Dialog

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Use this to create a dialog for file uploads. Specify the label and accepted file types.

```php
<?php

namespace App\Controller;

use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Pentiminax\UX\SweetAlert\InputType\File;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class AvatarController extends AbstractController
{
    #[Route('/profile/avatar', name: 'app_avatar')]
    public function uploadAvatar(AlertManagerInterface $alertManager): Response
    {
        $alertManager->input(
            inputType: new File(
                label: 'Choose an image',
                accept: 'image/png,image/jpeg,image/gif'
            ),
            title: 'Upload Avatar',
            text: 'Select an image file (PNG, JPG, or GIF).'
        )
            ->withCancelButton();

        return $this->render('profile/avatar.html.twig');
    }
}
```

--------------------------------

### AlertManagerInterface::input()

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Creates an input dialog for collecting user data via text or select inputs.

```APIDOC
## AlertManagerInterface::input()

### Description
Creates an input dialog with a field (Text or Select) for collecting user input.

### Parameters
- **inputType** (Object) - Required - The input type instance (Text or Select).
- **title** (string) - Required - The title of the dialog.
- **text** (string) - Required - The body text of the dialog.
- **callback** (string) - Required - The URL to handle the submitted input.
```

--------------------------------

### Configure a generic HTML input

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/reference/input-types.mdx

Use HtmlInputType for native HTML input types like email, password, or number that do not require specialized class logic.

```php
use Pentiminax\UX\SweetAlert\Enum\InputType;
use Pentiminax\UX\SweetAlert\InputType\HtmlInputType;

$alertManager->input(
    inputType: new HtmlInputType(
        type: InputType::Email,
        label: 'Work email',
        placeholder: 'name@company.com'
    ),
    title: 'Invite a colleague'
);
```

--------------------------------

### Create Radio Input Dialog

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Use this to create a dialog for single-choice selection with radio buttons. Configure options, label, and default value.

```php
<?php

namespace App\Controller;

use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Pentiminax\UX\SweetAlert\InputType\Radio;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class PriorityController extends AbstractController
{
    #[Route('/task/{id}/priority', name: 'app_task_priority')]
    public function setPriority(int $id, AlertManagerInterface $alertManager): Response
    {
        $alertManager->input(
            inputType: new Radio(
                options: [
                    'low' => 'Low Priority',
                    'medium' => 'Medium Priority',
                    'high' => 'High Priority',
                    'critical' => 'Critical',
                ],
                label: 'Priority Level',
                value: 'medium'
            ),
            title: 'Set Task Priority'
        )
            ->withCancelButton();

        return $this->render('task/priority.html.twig', ['id' => $id]);
    }
}
```

--------------------------------

### Apply a Bootstrap 5 Dark Theme

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/guide/themes-and-styling.mdx

Use the Theme enum to apply a specific framework theme to your alert. Ensure the matching SweetAlert2 CSS is imported by your asset pipeline.

```php
use Pentiminax\UX\SweetAlert\Enum\Theme;

$alertManager
    ->success('Saved')
    ->theme(Theme::Bootstrap5Dark);
```

--------------------------------

### Create Success Alert

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Displays a success alert with a green checkmark icon.

```php
<?php

namespace App\Controller;

use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class SettingsController extends AbstractController
{
    #[Route('/settings/save', name: 'app_settings_save', methods: ['POST'])]
    public function save(AlertManagerInterface $alertManager): Response
    {
        // Save settings logic here...

        $alertManager->success(
            title: 'Settings Saved',
            text: 'Your preferences have been updated successfully.'
        );

        return $this->redirectToRoute('app_dashboard');
    }
}
```

--------------------------------

### Implement InputModal component

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/integrations/live-components.mdx

Displays an input modal with specific input options and configuration.

```twig
<twig:SweetAlert:InputModal
    title="Choose a role"
    text="This will be applied immediately."
    inputType="select"
    inputLabel="Role"
    inputOptions='{"admin":"Admin","editor":"Editor"}'
    inputValue="editor"
/>
```

--------------------------------

### AlertManager::input() with HtmlInputType

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/reference/input-types.mdx

Demonstrates how to use the generic HtmlInputType class to create native HTML inputs like email, password, or number fields.

```APIDOC
## AlertManager::input()

### Description
Configures an Alert instance for SweetAlert2 input mode using a specific input type class.

### Parameters
#### Request Body
- **inputType** (Object) - Required - An instance of an InputType class (e.g., HtmlInputType, Text, Select).
- **title** (String) - Optional - The title of the SweetAlert modal.

### Request Example
```php
use Pentiminax\UX\SweetAlert\Enum\InputType;
use Pentiminax\UX\SweetAlert\InputType\HtmlInputType;

$alertManager->input(
    inputType: new HtmlInputType(
        type: InputType::Email,
        label: 'Work email',
        placeholder: 'name@company.com'
    ),
    title: 'Invite a colleague'
);
```
```

--------------------------------

### Manual HTMX Alert Dispatch with HxTriggerHelper

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/integrations/htmx.mdx

Use `HxTriggerHelper::withAlert()` when you need full control over the HTTP response object. This method allows you to attach a SweetAlert to a custom response.

```php
use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Pentiminax\UX\SweetAlert\Htmx\HxTriggerHelper;
use Symfony\Component\HttpFoundation\Response;

public function save(AlertManagerInterface $alertManager): Response
{
    $alert = $alertManager->success(
        title: 'Saved',
        text: 'Your changes are now persisted.'
    );

    return HxTriggerHelper::withAlert(new Response('OK'), $alert);
}
```

--------------------------------

### Render the Twig helper

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/getting-started/installation.mdx

Include the helper in your base layout to enable alert and toast rendering.

```twig
    <head>
        {{ ux_sweet_alert_scripts() }}
    </head>
```

--------------------------------

### Extend InputModal for Server-Side Handling

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Create custom components by extending InputModal to process results on the server.

```php
<?php

namespace App\Twig\Components;

use Pentiminax\UX\SweetAlert\Model\Result;
use Pentiminax\UX\SweetAlert\Twig\Components\InputModal;
use Symfony\UX\TwigComponent\Attribute\AsTwigComponent;

#[AsTwigComponent('ProjectNameModal')]
class ProjectNameModal extends InputModal
{
    protected function onResult(Result $result, array $args = []): void
    {
        if ($result->isConfirmed && $result->value) {
            // Create project with the provided name
            $projectName = $result->value;

            // Your project creation logic here...
        }
    }
}
```

```twig
{# templates/project/create.html.twig #}
<twig:ProjectNameModal
    title="Create New Project"
    inputType="text"
    inputLabel="Project Name"
    inputPlaceholder="my-project"
    validationMessage="Please enter a project name."
>
    New Project
</twig:ProjectNameModal>
```

--------------------------------

### Customize Button Colors and Apply Dark Theme

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/guide/themes-and-styling.mdx

Control individual button colors and apply a general theme. This allows for fine-grained styling beyond the default theme.

```php
$alertManager
    ->question('Archive item?')
    ->confirmButtonColor('#ff6b4f')
    ->cancelButtonColor('#2f4858')
    ->denyButtonColor('#f4b400')
    ->theme(Theme::Dark);
```

--------------------------------

### Create a Toast Notification

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

The `toast` method creates a non-blocking, auto-dismissing notification. Configure its appearance, position, and timer for user feedback.

```php
<?php

namespace App\Controller;

use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Pentiminax\UX\SweetAlert\Enum\Icon;
use Pentiminax\UX\SweetAlert\Enum\Position;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class ProfileController extends AbstractController
{
    #[Route('/profile/update', name: 'app_profile_update', methods: ['POST'])]
    public function update(AlertManagerInterface $alertManager): Response
    {
        // Update profile logic...

        $alertManager->toast(
            title: 'Profile Updated',
            text: 'Changes have been saved.',
            icon: Icon::SUCCESS,
            position: Position::TOP_END,
            timer: 3500,
            timerProgressBar: true
        );

        return $this->render('profile/index.html.twig');
    }
}
```

--------------------------------

### Configure alerts using the fluent API

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

The Alert object supports method chaining to customize modal appearance, buttons, and behavior.

```php
<?php

namespace App\Controller;

use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Pentiminax\UX\SweetAlert\Enum\Icon;
use Pentiminax\UX\SweetAlert\Enum\Position;
use Pentiminax\UX\SweetAlert\Enum\Theme;
use Pentiminax\UX\SweetAlert\Model\Alert;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class CustomAlertController extends AbstractController
{
    #[Route('/custom-alert', name: 'app_custom_alert')]
    public function customAlert(AlertManagerInterface $alertManager): Response
    {
        $alert = Alert::new(
            title: 'Custom Alert',
            text: 'This alert was built manually.',
            icon: Icon::INFO,
            position: Position::TOP
        )
            ->html('<strong>Rich HTML content</strong> is supported.')
            ->setFooter('Need help? <a href="/support">Contact support</a>')
            ->setImageUrl('/images/logo.png')
            ->setImageHeight(100)
            ->setImageAlt('Company Logo')
            ->theme(Theme::Bootstrap5)
            ->withCancelButton()
            ->withDenyButton()
            ->confirmButtonText('Accept')
            ->cancelButtonText('Decline')
            ->setDenyButtonText('Maybe Later')
            ->confirmButtonColor('#28a745')
            ->cancelButtonColor('#6c757d')
            ->denyButtonColor('#ffc107')
            ->reverseButtons()
            ->denyOutsideClick()
            ->denyEscapeKey()
            ->setDraggable(true)
            ->setFocusConfirm(false);

        $alertManager->addAlert($alert);

        return $this->render('custom/alert.html.twig');
    }
}
```

--------------------------------

### Ask for input from PHP

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/getting-started/quick-start.mdx

Use the input method with an input type object to prompt the user for data within a dialog.

```php
use Pentiminax\UX\SweetAlert\InputType\Text;

$alertManager->input(
    inputType: new Text(
        label: 'Display name',
        value: 'Tanguy',
        placeholder: 'Enter your public name'
    ),
    title: 'Update profile',
    text: 'This value will be shown to other users.'
);
```

--------------------------------

### Implement ConfirmButton component

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/integrations/live-components.mdx

Displays a confirmation modal using the SweetAlert ConfirmButton component.

```twig
<twig:SweetAlert:ConfirmButton
    title="Archive conversation?"
    text="This action cannot be undone."
    icon="warning"
    showCancelButton="true"
    confirmButtonText="Archive"
    cancelButtonText="Keep it"
/>
```

--------------------------------

### AlertManagerInterface::info()

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Triggers an informational alert with a blue info icon.

```APIDOC
## AlertManagerInterface::info()

### Description
Creates an informational alert with a blue info icon.

### Parameters
- **title** (string) - Required - The title of the alert.
- **text** (string) - Required - The body text of the alert.

### Request Example
$alertManager->info(title: 'Background Sync Finished', text: 'Your cache is fresh again.');
```

--------------------------------

### Storage Lifecycle

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/reference/alert-manager-and-alert-object.mdx

How alerts are stored and managed throughout their lifecycle.

```APIDOC
## Storage Lifecycle

### Description
Details the session storage mechanism for alerts.

### Storage Mechanism
Alerts are stored in the session under the `ux-sweet-alert:alerts` key. `getAlerts()` performs a consume-on-read operation, removing alerts from session storage after they have been retrieved for rendering.
```

--------------------------------

### AlertManagerInterface::toast()

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Creates a lightweight non-blocking toast notification.

```APIDOC
## AlertManagerInterface::toast()

### Description
Creates a lightweight non-blocking toast notification that auto-dismisses after a timer.

### Parameters
- **title** (string) - Required - The title of the toast.
- **text** (string) - Required - The body text of the toast.
- **icon** (Enum) - Optional - The icon type (e.g., SUCCESS).
- **position** (Enum) - Optional - The screen position of the toast.
- **timer** (int) - Optional - Auto-dismiss duration in milliseconds.
- **timerProgressBar** (bool) - Optional - Whether to show a progress bar.
```

--------------------------------

### Create a basic text input alert

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/guide/input-dialogs.mdx

Uses the Text input type to collect a simple string value with a label and placeholder.

```php
use Pentiminax\UX\SweetAlert\InputType\Text;

$alertManager->input(
    inputType: new Text(
        label: 'Display name',
        value: 'Tanguy',
        placeholder: 'Enter your public name'
    ),
    title: 'Update profile',
    text: 'This change is visible to other users.'
);
```

--------------------------------

### Handle browser callback

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/integrations/live-components.mdx

Executes a browser function when a confirmation action is triggered.

```twig
<twig:SweetAlert:ConfirmButton
    title="Confirm deletion"
    callback="handleDeletionConfirmation"
>
    Delete
</twig:SweetAlert:ConfirmButton>

<script>
  function handleDeletionConfirmation(result) {
    if (result.isConfirmed) {
      console.log('Confirmed')
    }
  }
</script>
```

--------------------------------

### AlertManagerInterface::success()

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Triggers a success alert with a green checkmark icon.

```APIDOC
## AlertManagerInterface::success()

### Description
Creates a success alert with a green checkmark icon. Returns the Alert object for fluent customization.

### Parameters
- **title** (string) - Required - The title of the alert.
- **text** (string) - Required - The body text of the alert.

### Request Example
$alertManager->success(title: 'Settings Saved', text: 'Your preferences have been updated successfully.');
```

--------------------------------

### Create Warning Alert

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Displays a warning alert with an orange exclamation icon, supporting fluent configuration methods.

```php
<?php

namespace App\Controller;

use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class DangerZoneController extends AbstractController
{
    #[Route('/danger-zone', name: 'app_danger_zone')]
    public function index(AlertManagerInterface $alertManager): Response
    {
        $alertManager->warning(
            title: 'Danger Zone',
            text: 'Only administrators should continue past this point.'
        )
            ->withCancelButton()
            ->denyOutsideClick()
            ->denyEscapeKey();

        return $this->render('danger_zone/index.html.twig');
    }
}
```

--------------------------------

### Typical SweetAlert Configuration Overrides

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/guide/configuration.mdx

Overrides the default SweetAlert configuration to enable flash message conversion and customize button text and visibility.

```yaml
sweet_alert:
  auto_convert_flash_messages: true
  defaults:
    position: 'top-end'
    confirmButtonText: 'Continue'
    cancelButtonText: 'Go back'
    showCancelButton: true
```

--------------------------------

### Alert Manager Methods

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/reference/alert-manager-and-alert-object.mdx

Methods available on the Alert Manager to create and manage alerts.

```APIDOC
## Alert Manager Methods

### Description
Methods to create and manage alerts using the Alert Manager.

### Methods
- **success(), error(), warning(), info(), question()**: Create modal alerts with a predefined icon.
- **toast()**: Create a non-blocking toast notification.
- **input()**: Create an alert configured by an input type object.
- **addAlert(Alert $alert)**: Push a manually created alert into storage.
- **getAlerts()**: Consume queued alerts, optionally converting flash messages.
```

--------------------------------

### Default SweetAlert Configuration

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/guide/configuration.mdx

Sets the default configuration for SweetAlert, including flash message conversion and various alert display options.

```yaml
sweet_alert:
  auto_convert_flash_messages: false
  defaults:
    position: 'center'
    confirmButtonColor: '#3085d6'
    cancelButtonColor: '#aaa'
    denyButtonColor: '#dd6b55'
    confirmButtonText: 'OK'
    cancelButtonText: 'Cancel'
    denyButtonText: 'No'
    showConfirmButton: true
    showCancelButton: false
    showDenyButton: false
    reverseButtons: false
    animation: true
    backdrop: true
    allowOutsideClick: true
    allowEscapeKey: true
    focusConfirm: true
    draggable: false
    topLayer: false
    timer: null
    timerProgressBar: false
    theme: 'auto'
    customClass: []
```

--------------------------------

### Queue an alert from a controller

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/getting-started/quick-start.mdx

Inject AlertManagerInterface into a controller method to trigger a success alert before redirecting.

```php
use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

final class SettingsController extends AbstractController
{
    #[Route('/settings/save', name: 'app_settings_save')]
    public function save(AlertManagerInterface $alertManager): Response
    {
        $alertManager->success(
            title: 'Settings saved',
            text: 'Your preferences have been updated.'
        );

        return $this->redirectToRoute('app_settings_show');
    }
}
```

--------------------------------

### Trigger alerts in HTMX responses

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Use HxTriggerHelper to inject alerts into the HX-Trigger header when Turbo is not available.

```php
<?php

namespace App\Controller;

use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Pentiminax\UX\SweetAlert\Htmx\HxTriggerHelper;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class HtmxController extends AbstractController
{
    #[Route('/htmx/save', name: 'app_htmx_save', methods: ['POST'])]
    public function save(AlertManagerInterface $alertManager): Response
    {
        // Save logic...

        $alert = $alertManager->success(
            title: 'Saved',
            text: 'Your changes are now persisted.'
        );

        // Returns response with header:
        // HX-Trigger: {"ux-sweet-alert:alert:added":{"alert":{...}}}
        return HxTriggerHelper::withAlert(new Response('OK'), $alert);
    }
}
```

--------------------------------

### Create Error Alert

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Displays an error alert with a red X icon.

```php
<?php

namespace App\Controller;

use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class UploadController extends AbstractController
{
    #[Route('/upload', name: 'app_upload', methods: ['POST'])]
    public function upload(AlertManagerInterface $alertManager): Response
    {
        // Upload fails...

        $alertManager->error(
            title: 'Upload Failed',
            text: 'The file size exceeds the maximum allowed limit of 10MB.'
        );

        return $this->redirectToRoute('app_files');
    }
}
```

--------------------------------

### Create select and radio input alerts

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/guide/input-dialogs.mdx

Utilizes Select or Radio input types which require an options array to populate the input choices.

```php
use Pentiminax\UX\SweetAlert\InputType\Select;

$alertManager->input(
    inputType: new Select(
        options: [
            'admin' => 'Admin',
            'editor' => 'Editor',
        ],
        label: 'Role',
        value: 'editor'
    ),
    title: 'Invite user'
);
```

--------------------------------

### Create Toast Notifications

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/README.md

Use the toast method on the AlertManagerInterface to display non-blocking notifications.

```php
use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Pentiminax\UX\SweetAlert\Enum\Position;

class HomeController extends AbstractController
{
    #[Route('/', name: 'app_homepage')]
    public function index(AlertManagerInterface $alertManager): Response
    {
       $alertManager->toast(
            title: 'title',
            text: 'text',
            position: Position::TOP_END,
            timer: 3000,
            timerProgressBar: true
        );

        return $this->render('home/index.html.twig');
    }
}
```

--------------------------------

### Basic Toast Notification

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/guide/toasts.mdx

Use this to display a simple toast message with a title, text, position, and timer. Ensure AlertManagerInterface and Position enum are imported.

```php
use Pentiminax\UX\SweetAlert\AlertManagerInterface;
use Pentiminax\UX\SweetAlert\Enum\Position;

$alertManager->toast(
    title: 'Profile updated',
    text: 'Changes have been saved.',
    position: Position::BOTTOM_END,
    timer: 3500,
    timerProgressBar: true
);
```

--------------------------------

### Alert Object Capabilities

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/reference/alert-manager-and-alert-object.mdx

Available methods for customizing the Alert object.

```APIDOC
## Selected `Alert` Capabilities

### Description
Methods to customize various aspects of an `Alert` object.

### Categories and Methods

#### Buttons
- **withCancelButton()**
- **withDenyButton()**
- **withoutConfirmButton()**
- **reverseButtons()**
- **confirmButtonText(string $text)**
- **cancelButtonText(string $text)**
- **setDenyButtonText(string $text)**

#### Behavior
- **withoutAnimation()**
- **withoutBackdrop()**
- **denyOutsideClick()**
- **denyEscapeKey()**
- **setFocusConfirm()**
- **setDraggable()**
- **setTopLayer()**

#### Layout
- **position(string $position)**
- **theme(string $theme)**
- **customClass(array $classes)** (via manager helper arguments)

#### Content
- **html(string $html)**
- **setFooter(string $footerHtml)**
- **setImageUrl(string $url)**
- **setImageAlt(string $alt)**
- **setImageHeight(string $height)**

#### Input-related
- **input(string $type)**
- **inputLabel(string $label)**
- **inputPlaceholder(string $placeholder)**
- **inputValue(mixed $value)**
- **inputAttributes(array $attributes)**
- **inputOptions(array $options)**
- **validationMessage(string $message)**
- **returnInputValueOnDeny()**

#### Callbacks
- **callbackUrl(string $url)**
```

--------------------------------

### Alert Serialization

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/reference/alert-manager-and-alert-object.mdx

Details on how the Alert object is serialized to JSON.

```APIDOC
## Serialization

### Description
Explains the JSON payload structure when an `Alert` object is serialized.

### JSON Payload Contents
The `Alert` object implements `JsonSerializable`. The JSON payload sent to the frontend includes:
- Modal settings
- When relevant:
  - `toast`, `timer`, and `timerProgressBar` for toast mode
  - `backdrop` and `allowOutsideClick` for modal mode
  - `callbackUrl` when a backend callback was configured.
```

--------------------------------

### Queue a toast notification

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/getting-started/quick-start.mdx

Use the toast method to display a non-blocking notification with specific positioning and timer settings.

```php
use Pentiminax\UX\SweetAlert\Enum\Position;

$alertManager->toast(
    title: 'Profile updated',
    text: 'Changes were saved successfully.',
    position: Position::TOP_END,
    timer: 3000,
    timerProgressBar: true
);
```

--------------------------------

### Post input results to a Symfony controller

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/guide/input-dialogs.mdx

Provides a callback URL to handle the SweetAlert result via a POST request.

```php
use Pentiminax\UX\SweetAlert\InputType\Text;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;

$alertManager->input(
    inputType: new Text(label: 'Project name'),
    title: 'Create project',
    callback: $this->generateUrl('app_project_modal_result', referenceType: UrlGeneratorInterface::ABSOLUTE_URL)
);
```

--------------------------------

### Render SweetAlert Scripts in Twig

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Include the required JavaScript assets in your base template.

```twig
{# base.html.twig #}
<!DOCTYPE html>
<html>
<head>
    {{ ux_sweet_alert_scripts() }}
</head>
<body>
    {% block body %}{% endblock %}
</body>
</html>
```

--------------------------------

### Symfony Queue Events

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/reference/alert-manager-and-alert-object.mdx

Information about Symfony events dispatched during the alert queuing process.

```APIDOC
## Symfony Queue Events

### Description
Details the Symfony events dispatched by the Alert Manager.

### Events

#### `BeforeAlertQueuedEvent`
- **When it fires**: Before the alert is stored in session/context.
- **Typical use**: Enrich or adjust the mutable `Alert` instance.

#### `AlertQueuedEvent`
- **When it fires**: After the alert has been stored.
- **Typical use**: Observe, log, or trigger side effects.

Listeners receive the same `Alert` object that the manager persists. Changes made during `BeforeAlertQueuedEvent` are reflected in storage and rendering.

### Example Listener
```php
use Pentiminax\UX\SweetAlert\Event\BeforeAlertQueuedEvent;
use Pentiminax\UX\SweetAlert\Enum\Theme;
use Symfony\Component\EventDispatcher\Attribute\AsEventListener;

#[AsEventListener]
final class BrandAlertsListener
{
    public function __invoke(BeforeAlertQueuedEvent $event): void
    {
        $event->getAlert()
            ->theme(Theme::Dark)
            ->withCancelButton();
    }
}
```
```

--------------------------------

### Toast Notification with Icon

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/guide/toasts.mdx

Add an icon to your toast notification for visual emphasis. Import the Icon enum for this functionality.

```php
use Pentiminax\UX\SweetAlert\Enum\Icon;

$alertManager->toast(
    title: 'Heads up',
    text: 'You are close to your rate limit.',
    icon: Icon::WARNING,
    timer: 5000
);
```

--------------------------------

### UX SweetAlert Icon Enum Values

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Lists the available icons within the Icon enum. Each icon corresponds to a specific visual representation for alerts.

```php
<?php

use Pentiminax\UX\SweetAlert\Enum\Icon;

// Available icons:
Icon::SUCCESS;   // 'success' - green checkmark
Icon::ERROR;     // 'error' - red X
Icon::WARNING;   // 'warning' - orange exclamation
Icon::INFO;      // 'info' - blue info icon
Icon::QUESTION;  // 'question' - blue question mark
```

--------------------------------

### Implement ConfirmButton Component in Twig

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Use the ConfirmButton component to trigger confirmation dialogs with optional browser callbacks and custom styling.

```twig
{# templates/article/delete.html.twig #}

{# Basic usage #}
<twig:SweetAlert:ConfirmButton
    title="Delete Article?"
    text="This action cannot be undone."
    icon="warning"
    showCancelButton="true"
    confirmButtonText="Delete"
    cancelButtonText="Keep it"
>
    Delete Article
</twig:SweetAlert:ConfirmButton>

{# With browser callback #}
<twig:SweetAlert:ConfirmButton
    title="Archive Conversation?"
    text="The conversation will be moved to archives."
    icon="question"
    showCancelButton="true"
    callback="handleArchiveConfirmation"
    confirmButtonText="Archive"
>
    Archive
</twig:SweetAlert:ConfirmButton>

<script>
function handleArchiveConfirmation(result) {
    if (result.isConfirmed) {
        fetch('/api/conversation/123/archive', { method: 'POST' })
            .then(() => window.location.reload());
    }
}
</script>

{# With custom classes #}
<twig:SweetAlert:ConfirmButton
    title="Confirm Action"
    text="Are you sure?"
    icon="question"
    customClass='{"popup":"my-popup","confirmButton":"btn-danger"}'
>
    Confirm
</twig:SweetAlert:ConfirmButton>
```

--------------------------------

### Create Alerts with AlertManagerInterface

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/README.md

Inject the AlertManagerInterface into your controller to trigger success or other alert types.

```php
use Pentiminax\UX\SweetAlert\AlertManagerInterface;

#[Route('/', name: 'app_homepage')]
public function index(AlertManagerInterface $alertManager): Response
{
    $alertManager->success(
        title: 'Update Successful',
        text: 'Your settings have been saved.'
    );

    return $this->redirectToRoute('dashboard');
}
```

--------------------------------

### AlertManagerInterface::warning()

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Triggers a warning alert with an orange exclamation icon.

```APIDOC
## AlertManagerInterface::warning()

### Description
Creates a warning alert with an orange exclamation icon for cautionary messages. Supports fluent methods like withCancelButton(), denyOutsideClick(), and denyEscapeKey().

### Parameters
- **title** (string) - Required - The title of the alert.
- **text** (string) - Required - The body text of the alert.

### Request Example
$alertManager->warning(title: 'Danger Zone', text: 'Only administrators should continue past this point.')->withCancelButton();
```

--------------------------------

### AlertManagerInterface::error()

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Triggers an error alert with a red X icon.

```APIDOC
## AlertManagerInterface::error()

### Description
Creates an error alert with a red X icon for displaying failures or validation errors.

### Parameters
- **title** (string) - Required - The title of the alert.
- **text** (string) - Required - The body text of the alert.

### Request Example
$alertManager->error(title: 'Upload Failed', text: 'The file size exceeds the maximum allowed limit of 10MB.');
```

--------------------------------

### Implement InputModal Component in Twig

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Use the InputModal component to collect user input via text, select, or textarea fields.

```twig
{# templates/team/invite.html.twig #}

{# Text input #}
<twig:SweetAlert:InputModal
    title="Enter Project Name"
    text="Choose a unique name for your project."
    inputType="text"
    inputLabel="Project Name"
    inputPlaceholder="my-awesome-project"
    inputValue=""
    validationMessage="Project name is required."
    showCancelButton="true"
>
    Create Project
</twig:SweetAlert:InputModal>

{# Select input #}
<twig:SweetAlert:InputModal
    title="Choose Role"
    text="Select the role for the new team member."
    inputType="select"
    inputLabel="Role"
    inputOptions='{"admin":"Administrator","editor":"Editor","viewer":"Viewer"}'
    inputValue="viewer"
>
    Invite Member
</twig:SweetAlert:InputModal>

{# Textarea input #}
<twig:SweetAlert:InputModal
    title="Leave a Note"
    inputType="textarea"
    inputLabel="Note"
    inputPlaceholder="Type your note here..."
    inputAttributes='{"rows":"4"}'
    returnInputValueOnDeny="true"
>
    Add Note
</twig:SweetAlert:InputModal>
```

--------------------------------

### Include SweetAlert Scripts in Twig

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/README.md

Add this Twig function to your base layout file to enable SweetAlert functionality.

```twig
{{ ux_sweet_alert_scripts() }}
```

--------------------------------

### Customize Alert Before Queuing

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/reference/alert-manager-and-alert-object.mdx

Use BeforeAlertQueuedEvent to modify an Alert instance before it is stored. This listener applies a dark theme and adds a cancel button to the alert.

```php
use Pentiminax\UX\SweetAlert\Event\BeforeAlertQueuedEvent;
use Pentiminax\UX\SweetAlert\Enum\Theme;
use Symfony\Component\EventDispatcher\Attribute\AsEventListener;

#[AsEventListener]
final class BrandAlertsListener
{
    public function __invoke(BeforeAlertQueuedEvent $event): void
    {
        $event->getAlert()
            ->theme(Theme::Dark)
            ->withCancelButton();
    }
}
```

--------------------------------

### Access Theme Enum Values

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Use the Theme enum to select the visual style of the SweetAlert2 modal.

```php
<?php

use Pentiminax\UX\SweetAlert\Enum\Theme;

// Available themes:
Theme::Light;            // 'light'
Theme::Dark;             // 'dark'
Theme::Auto;             // 'auto' (follows system preference)
Theme::Borderless;       // 'borderless'
Theme::Bootstrap4;       // 'bootstrap-4'
Theme::Bootstrap4Light;  // 'bootstrap-4-light'
Theme::Bootstrap4Dark;   // 'bootstrap-4-dark'
Theme::Bootstrap5;       // 'bootstrap-5'
Theme::Bootstrap5Light;  // 'bootstrap-5-light'
Theme::Bootstrap5Dark;   // 'bootstrap-5-dark'
Theme::MaterialUI;       // 'material-ui'
Theme::MaterialUILight;  // 'material-ui-light'
Theme::MaterialUIDark;   // 'material-ui-dark'
Theme::Bulma;            // 'bulma'
Theme::BulmaLight;       // 'bulma-light'
Theme::BulmaDark;        // 'bulma-dark'
Theme::Minimal;          // 'minimal'
Theme::EmbedIframe;      // 'embed-iframe'
```

--------------------------------

### Customize alerts with validation and attributes

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/guide/input-dialogs.mdx

Allows chaining methods on the returned Alert object to add validation messages or additional buttons.

```php
$alertManager
    ->input(
        inputType: new Text(
            label: 'Display name',
            inputAttributes: ['maxlength' => '40']
        ),
        title: 'Update profile'
    )
    ->validationMessage('A display name is required.')
    ->withCancelButton();
```

--------------------------------

### Turbo Stream HTML Fragment

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/integrations/turbo.mdx

The rendered fragment appended to HTML responses when Turbo is enabled.

```html
<turbo-stream action="alert">
    <template>{"title":"Saved","icon":"success"}</template>
</turbo-stream>
```

--------------------------------

### Access Position Enum Values

Source: https://context7.com/pentiminax/ux-sweet-alert/llms.txt

Use the Position enum to define the placement of modals.

```php
<?php

use Pentiminax\UX\SweetAlert\Enum\Position;

// Available positions:
Position::TOP;          // 'top'
Position::TOP_START;    // 'top-start'
Position::TOP_END;      // 'top-end'
Position::CENTER;       // 'center' (default for alerts)
Position::CENTER_START; // 'center-start'
Position::CENTER_END;   // 'center-end'
Position::BOTTOM;       // 'bottom'
Position::BOTTOM_START; // 'bottom-start'
Position::BOTTOM_END;   // 'bottom-end' (default for toasts)
```

--------------------------------

### Define the Result value object

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/reference/result-and-callbacks.mdx

The Result class is an immutable value object representing the outcome of a SweetAlert interaction.

```php
final readonly class Result
{
    public function __construct(
        public bool $isConfirmed = false,
        public bool $isDenied = false,
        public bool $isDismissed = false,
        public mixed $value = null,
    ) {
    }
}
```

--------------------------------

### Resolve Result in a controller

Source: https://github.com/pentiminax/ux-sweet-alert/blob/main/docs/src/content/docs/reference/result-and-callbacks.mdx

The ResultValueResolver automatically hydrates a Result argument from the JSON request body in a controller.

```php
use Pentiminaxlux
esult
use Pentiminax\UX\SweetAlert\Model\Result;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

#[Route('/modal/result', name: 'app_modal_result', methods: ['POST'])]
public function __invoke(Result $result): Response
{
    if ($result->isConfirmed) {
        // Persist the submitted value or continue the workflow.
    }

    return new Response(status: 204);
}
```
Tokens:
Raw