├── .github
    ├── FUNDING.yml
    ├── PULL_REQUEST_TEMPLATE.md
    └── workflows
    │   └── close-pull-request.yml
├── .phpstorm.meta.php
├── Attribute
    ├── AsFlasherFactory.php
    └── AsFlasherPresenter.php
├── Command
    └── InstallCommand.php
├── Component
    └── FlasherComponent.php
├── DependencyInjection
    ├── Compiler
    │   ├── EventListenerCompilerPass.php
    │   └── PresenterCompilerPass.php
    ├── Configuration.php
    └── FlasherExtension.php
├── EventListener
    ├── FlasherListener.php
    └── SessionListener.php
├── Factory
    └── NotificationFactoryLocator.php
├── FlasherSymfonyBundle.php
├── Http
    ├── Request.php
    └── Response.php
├── LICENSE
├── Profiler
    └── FlasherDataCollector.php
├── README.md
├── Resources
    ├── config
    │   ├── config.yaml
    │   └── services.php
    ├── translations
    │   ├── flasher.ar.php
    │   ├── flasher.de.php
    │   ├── flasher.en.php
    │   ├── flasher.es.php
    │   ├── flasher.fr.php
    │   ├── flasher.pt.php
    │   ├── flasher.ru.php
    │   └── flasher.zh.php
    └── views
    │   ├── bootstrap.html.twig
    │   ├── components
    │       └── flasher.html.twig
    │   ├── profiler
    │       ├── _notifications_table.html.twig
    │       ├── flasher.html.twig
    │       └── flasher.svg
    │   ├── tailwindcss.html.twig
    │   ├── tailwindcss_bg.html.twig
    │   └── tailwindcss_r.html.twig
├── Storage
    ├── FallbackSession.php
    ├── FallbackSessionInterface.php
    └── SessionBag.php
├── Support
    ├── PluginBundle.php
    └── PluginBundleInterface.php
├── Template
    └── TwigTemplateEngine.php
├── Translation
    └── Translator.php
├── Twig
    └── FlasherTwigExtension.php
└── composer.json


/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | github: yoeunes
2 | 


--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE.md:
--------------------------------------------------------------------------------
1 | Please do not submit any Pull Requests here. They will be closed.
2 | ---
3 | 
4 | Please submit your PR here instead:
5 | https://github.com/php-flasher/php-flasher
6 | 
7 | This repository is what we call a "subtree split": a read-only subset of that main repository.
8 | We're looking forward to your PR there!
9 | 


--------------------------------------------------------------------------------
/.github/workflows/close-pull-request.yml:
--------------------------------------------------------------------------------
 1 | name: Close Pull Request
 2 | 
 3 | on:
 4 |     pull_request_target:
 5 |         types: [opened]
 6 | 
 7 | jobs:
 8 |     run:
 9 |         runs-on: ubuntu-latest
10 |         steps:
11 |             - uses: superbrothers/close-pull-request@v3
12 |               with:
13 |                   comment: |
14 |                       Thanks for your Pull Request! We love contributions.
15 | 
16 |                       However, you should instead open your PR on the main repository:
17 |                       https://github.com/php-flasher/php-flasher
18 | 
19 |                       This repository is what we call a "subtree split": a read-only subset of that main repository.
20 |                       We're looking forward to your PR there!
21 | 


--------------------------------------------------------------------------------
/.phpstorm.meta.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace PHPSTORM_META;
4 | 
5 | registerArgumentsSet('types', 'success', 'error', 'warning', 'info');
6 | 
7 | expectedArguments(\Symfony\Bundle\FrameworkBundle\Controller\AbstractController::addFlash(), 0, argumentsSet('types'));
8 | expectedArguments(\Symfony\Component\HttpFoundation\Session\Flash\FlashBagInterface::add(), 0, argumentsSet('types'));
9 | 


--------------------------------------------------------------------------------
/Attribute/AsFlasherFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Flasher\Symfony\Attribute;
 6 | 
 7 | /**
 8 |  * AsFlasherFactory - Attribute for tagging notification factories.
 9 |  *
10 |  * This attribute enables auto-configuration of notification factory services in Symfony.
11 |  * When applied to a factory class, it automatically registers the class with the container
12 |  * using the specified alias, making it available to the PHPFlasher system.
13 |  *
14 |  * Design patterns:
15 |  * - Attribute-based Configuration: Uses PHP 8 attributes for declarative service configuration
16 |  * - Service Tagging: Implements Symfony's tag-based service discovery mechanism
17 |  *
18 |  * Usage:
19 |  * ```php
20 |  * #[AsFlasherFactory('toastr')]
21 |  * class ToastrFactory implements NotificationFactoryInterface
22 |  * {
23 |  *     // ...
24 |  * }
25 |  * ```
26 |  */
27 | #[\Attribute(\Attribute::TARGET_CLASS)]
28 | final readonly class AsFlasherFactory
29 | {
30 |     /**
31 |      * Creates a new AsFlasherFactory attribute.
32 |      *
33 |      * @param string $alias The unique alias for the notification factory (e.g., 'toastr', 'noty')
34 |      */
35 |     public function __construct(public string $alias)
36 |     {
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/Attribute/AsFlasherPresenter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Flasher\Symfony\Attribute;
 6 | 
 7 | /**
 8 |  * AsFlasherPresenter - Attribute for tagging response presenters.
 9 |  *
10 |  * This attribute enables auto-configuration of response presenter services in Symfony.
11 |  * When applied to a presenter class, it automatically registers the class with the
12 |  * container using the specified alias, making it available to PHPFlasher's response system.
13 |  *
14 |  * Design patterns:
15 |  * - Attribute-based Configuration: Uses PHP 8 attributes for declarative service configuration
16 |  * - Service Tagging: Implements Symfony's tag-based service discovery mechanism
17 |  * - Strategy Pattern: Supports pluggable response formatting strategies
18 |  *
19 |  * Usage:
20 |  * ```php
21 |  * #[AsFlasherPresenter('html')]
22 |  * class HtmlPresenter implements PresenterInterface
23 |  * {
24 |  *     // ...
25 |  * }
26 |  * ```
27 |  */
28 | #[\Attribute(\Attribute::TARGET_CLASS)]
29 | final readonly class AsFlasherPresenter
30 | {
31 |     /**
32 |      * Creates a new AsFlasherPresenter attribute.
33 |      *
34 |      * @param string $alias The unique alias for the presenter (e.g., 'html', 'json')
35 |      */
36 |     public function __construct(public string $alias)
37 |     {
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/Command/InstallCommand.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Flasher\Symfony\Command;
  6 | 
  7 | use Flasher\Prime\Asset\AssetManagerInterface;
  8 | use Flasher\Prime\Plugin\PluginInterface;
  9 | use Flasher\Symfony\Support\PluginBundleInterface;
 10 | use Symfony\Bundle\FrameworkBundle\Console\Application;
 11 | use Symfony\Component\Console\Command\Command;
 12 | use Symfony\Component\Console\Input\InputInterface;
 13 | use Symfony\Component\Console\Input\InputOption;
 14 | use Symfony\Component\Console\Output\OutputInterface;
 15 | use Symfony\Component\Filesystem\Filesystem;
 16 | use Symfony\Component\Finder\Finder;
 17 | use Symfony\Component\HttpKernel\KernelInterface;
 18 | 
 19 | /**
 20 |  * InstallCommand - Console command for installing PHPFlasher resources.
 21 |  *
 22 |  * This command provides a CLI interface for installing PHPFlasher resources,
 23 |  * including assets (JS and CSS files) and configuration files. It discovers
 24 |  * all registered PHPFlasher plugins and installs their resources.
 25 |  *
 26 |  * Design patterns:
 27 |  * - Command Pattern: Implements the command pattern for console interaction
 28 |  * - Discovery Pattern: Automatically discovers and processes registered plugins
 29 |  * - Template Method Pattern: Defines a structured workflow with specific steps
 30 |  */
 31 | final class InstallCommand extends Command
 32 | {
 33 |     /**
 34 |      * Creates a new InstallCommand instance.
 35 |      *
 36 |      * @param AssetManagerInterface $assetManager Manager for handling PHPFlasher assets
 37 |      */
 38 |     public function __construct(private readonly AssetManagerInterface $assetManager)
 39 |     {
 40 |         parent::__construct();
 41 |     }
 42 | 
 43 |     /**
 44 |      * Configure the command options and help text.
 45 |      */
 46 |     protected function configure(): void
 47 |     {
 48 |         $this
 49 |             ->setName('flasher:install')
 50 |             ->setDescription('Installs all <fg=blue;options=bold>PHPFlasher</> resources to the <comment>public</comment> and <comment>config</comment> directories.')
 51 |             ->setHelp('The command copies <fg=blue;options=bold>PHPFlasher</> assets to <comment>public/vendor/flasher/</comment> directory and config files to the <comment>config/packages/</comment> directory without overwriting any existing config files.')
 52 |             ->addOption('config', 'c', InputOption::VALUE_NONE, 'Publish all config files to the <comment>config/packages/</comment> directory.')
 53 |             ->addOption('symlink', 's', InputOption::VALUE_NONE, 'Symlink <fg=blue;options=bold>PHPFlasher</> assets instead of copying them.');
 54 |     }
 55 | 
 56 |     /**
 57 |      * Execute the command to install PHPFlasher resources.
 58 |      *
 59 |      * This method processes each registered bundle that implements PluginBundleInterface,
 60 |      * installing its assets and configuration files as requested.
 61 |      *
 62 |      * @param InputInterface  $input  The input interface
 63 |      * @param OutputInterface $output The output interface
 64 |      *
 65 |      * @return int Command status code (SUCCESS or FAILURE)
 66 |      */
 67 |     protected function execute(InputInterface $input, OutputInterface $output): int
 68 |     {
 69 |         // Display PHPFlasher banner and info message
 70 |         $output->writeln('');
 71 |         $output->writeln('<fg=blue;options=bold>
 72 |             ██████╗ ██╗  ██╗██████╗ ███████╗██╗      █████╗ ███████╗██╗  ██╗███████╗██████╗
 73 |             ██╔══██╗██║  ██║██╔══██╗██╔════╝██║     ██╔══██╗██╔════╝██║  ██║██╔════╝██╔══██╗
 74 |             ██████╔╝███████║██████╔╝█████╗  ██║     ███████║███████╗███████║█████╗  ██████╔╝
 75 |             ██╔═══╝ ██╔══██║██╔═══╝ ██╔══╝  ██║     ██╔══██║╚════██║██╔══██║██╔══╝  ██╔══██╗
 76 |             ██║     ██║  ██║██║     ██║     ███████╗██║  ██║███████║██║  ██║███████╗██║  ██║
 77 |             ╚═╝     ╚═╝  ╚═╝╚═╝     ╚═╝     ╚══════╝╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝
 78 |         </>');
 79 |         $output->writeln('');
 80 | 
 81 |         $output->writeln('');
 82 |         $output->writeln('<bg=blue;options=bold> INFO </> Copying <fg=blue;options=bold>PHPFlasher</> resources...');
 83 |         $output->writeln('');
 84 | 
 85 |         // Get application and validate it's a Symfony application
 86 |         $application = $this->getApplication();
 87 |         if (!$application instanceof Application) {
 88 |             return self::SUCCESS;
 89 |         }
 90 | 
 91 |         // Process command options
 92 |         $useSymlinks = (bool) $input->getOption('symlink');
 93 |         if ($useSymlinks) {
 94 |             $output->writeln('<info>Using symlinks to publish assets.</info>');
 95 |         } else {
 96 |             $output->writeln('<info>Copying assets to the public directory.</info>');
 97 |         }
 98 | 
 99 |         $publishConfig = (bool) $input->getOption('config');
100 |         if ($publishConfig) {
101 |             $output->writeln('<info>Publishing configuration files.</info>');
102 |         }
103 | 
104 |         // Prepare directories
105 |         $publicDir = $this->getPublicDir().'/vendor/flasher/';
106 |         $configDir = $this->getConfigDir();
107 | 
108 |         $filesystem = new Filesystem();
109 |         $filesystem->remove($publicDir);
110 |         $filesystem->mkdir($publicDir);
111 | 
112 |         // Process each plugin bundle
113 |         $files = [];
114 |         $exitCode = self::SUCCESS;
115 | 
116 |         $kernel = $application->getKernel();
117 |         foreach ($kernel->getBundles() as $bundle) {
118 |             if (!$bundle instanceof PluginBundleInterface) {
119 |                 continue;
120 |             }
121 | 
122 |             $plugin = $bundle->createPlugin();
123 |             $configFile = $bundle->getConfigurationFile();
124 | 
125 |             try {
126 |                 // Install assets and config
127 |                 $files[] = $this->publishAssets($plugin, $publicDir, $useSymlinks);
128 | 
129 |                 if ($publishConfig) {
130 |                     $this->publishConfig($plugin, $configDir, $configFile);
131 |                 }
132 | 
133 |                 // Report success
134 |                 $status = \sprintf('<fg=green;options=bold>%s</>', '\\' === \DIRECTORY_SEPARATOR ? 'OK' : "\xE2\x9C\x94" /* HEAVY CHECK MARK (U+2714) */);
135 |                 $output->writeln(\sprintf(' %s <fg=blue;options=bold>%s</>', $status, $plugin->getAlias()));
136 |             } catch (\Exception $e) {
137 |                 // Report failure
138 |                 $exitCode = self::FAILURE;
139 |                 $status = \sprintf('<fg=red;options=bold>%s</>', '\\' === \DIRECTORY_SEPARATOR ? 'ERROR' : "\xE2\x9C\x98" /* HEAVY BALLOT X (U+2718) */);
140 |                 $output->writeln(\sprintf(' %s <fg=blue;options=bold>%s</> <error>%s</error>', $status, $plugin->getAlias(), $e->getMessage()));
141 |             }
142 |         }
143 | 
144 |         $output->writeln('');
145 | 
146 |         // Display final status message
147 |         if (self::SUCCESS === $exitCode) {
148 |             $message = '<fg=blue;options=bold>PHPFlasher</> resources have been successfully installed.';
149 |             if ($publishConfig) {
150 |                 $message .= ' Configuration files have been published.';
151 |             }
152 |             if ($useSymlinks) {
153 |                 $message .= ' Assets were symlinked.';
154 |             }
155 |             $output->writeln("<bg=green;options=bold> SUCCESS </> <fg=blue;options=bold>$message</>");
156 |         } else {
157 |             $output->writeln('<bg=red;options=bold> ERROR </> An error occurred during the installation of <fg=blue;options=bold>PHPFlasher</> resources.');
158 |         }
159 | 
160 |         // Create asset manifest
161 |         $this->assetManager->createManifest(array_merge([], ...$files));
162 | 
163 |         $output->writeln('');
164 | 
165 |         return $exitCode;
166 |     }
167 | 
168 |     /**
169 |      * Publishes assets from the plugin's assets directory to the public directory.
170 |      *
171 |      * This method copies or symlinks asset files from the plugin's assets directory
172 |      * to the public directory for web access.
173 |      *
174 |      * @param PluginInterface $plugin      The plugin containing assets
175 |      * @param string          $publicDir   Target directory for assets
176 |      * @param bool            $useSymlinks Whether to symlink files instead of copying
177 |      *
178 |      * @return string[] List of target paths for generated manifest
179 |      */
180 |     private function publishAssets(PluginInterface $plugin, string $publicDir, bool $useSymlinks): array
181 |     {
182 |         $originDir = $plugin->getAssetsDir();
183 | 
184 |         if (!is_dir($originDir)) {
185 |             return [];
186 |         }
187 | 
188 |         $filesystem = new Filesystem();
189 |         $finder = new Finder();
190 |         $finder->files()->in($originDir);
191 | 
192 |         $files = [];
193 | 
194 |         foreach ($finder as $file) {
195 |             $relativePath = trim(str_replace($originDir, '', $file->getRealPath()), \DIRECTORY_SEPARATOR);
196 |             $targetPath = $publicDir.$relativePath;
197 | 
198 |             if ($useSymlinks) {
199 |                 $filesystem->symlink($file->getRealPath(), $targetPath);
200 |             } else {
201 |                 $filesystem->copy($file->getRealPath(), $targetPath, true);
202 |             }
203 | 
204 |             $files[] = $targetPath;
205 |         }
206 | 
207 |         return $files;
208 |     }
209 | 
210 |     /**
211 |      * Publishes configuration files to the application's config directory.
212 |      *
213 |      * This method copies plugin configuration files to the Symfony config directory,
214 |      * but only if the target file doesn't already exist (to avoid overwriting user customizations).
215 |      *
216 |      * @param PluginInterface $plugin     The plugin containing configuration
217 |      * @param string|null     $configDir  Target config directory
218 |      * @param string          $configFile Source configuration file path
219 |      */
220 |     private function publishConfig(PluginInterface $plugin, ?string $configDir, string $configFile): void
221 |     {
222 |         if (null === $configDir || !file_exists($configFile)) {
223 |             return;
224 |         }
225 | 
226 |         $target = $configDir.$plugin->getName().'.yaml';
227 |         if (file_exists($target)) {
228 |             return;
229 |         }
230 | 
231 |         $filesystem = new Filesystem();
232 |         $filesystem->copy($configFile, $target);
233 |     }
234 | 
235 |     /**
236 |      * Gets the path to the public directory.
237 |      *
238 |      * This method tries to locate the public directory using multiple strategies:
239 |      * 1. First, it looks for a standard 'public' directory in the project
240 |      * 2. If not found, it falls back to the composer.json configuration
241 |      *
242 |      * @return string|null Path to the public directory or null if not found
243 |      */
244 |     private function getPublicDir(): ?string
245 |     {
246 |         $projectDir = $this->getProjectDir();
247 |         if (null === $projectDir) {
248 |             return null;
249 |         }
250 | 
251 |         $publicDir = rtrim($projectDir, '/').'/public';
252 | 
253 |         if (is_dir($publicDir)) {
254 |             return $publicDir;
255 |         }
256 | 
257 |         return $this->getComposerDir('public-dir');
258 |     }
259 | 
260 |     /**
261 |      * Gets the path to the config directory.
262 |      *
263 |      * This method tries to locate the config/packages directory using multiple strategies:
264 |      * 1. First, it looks for a standard 'config/packages' directory in the project
265 |      * 2. If not found, it falls back to the composer.json configuration
266 |      *
267 |      * @return string|null Path to the config directory or null if not found
268 |      */
269 |     private function getConfigDir(): ?string
270 |     {
271 |         $projectDir = $this->getProjectDir();
272 | 
273 |         if (null === $projectDir) {
274 |             return null;
275 |         }
276 | 
277 |         $configDir = rtrim($projectDir, '/').'/config/packages/';
278 | 
279 |         if (is_dir($configDir)) {
280 |             return $configDir;
281 |         }
282 | 
283 |         return $this->getComposerDir('config-dir');
284 |     }
285 | 
286 |     /**
287 |      * Gets the project root directory from the kernel.
288 |      *
289 |      * @return string|null The project directory path or null if not available
290 |      */
291 |     private function getProjectDir(): ?string
292 |     {
293 |         $kernel = $this->getKernel();
294 | 
295 |         if (null === $kernel) {
296 |             return null;
297 |         }
298 | 
299 |         $container = $kernel->getContainer();
300 | 
301 |         $projectDir = $container->getParameter('kernel.project_dir');
302 | 
303 |         return \is_string($projectDir) ? $projectDir : null;
304 |     }
305 | 
306 |     /**
307 |      * Gets a directory path from composer.json extra configuration.
308 |      *
309 |      * @param string $dir The directory key to look for in composer.json extra section
310 |      *
311 |      * @return string|null The directory path or null if not found
312 |      */
313 |     private function getComposerDir(string $dir): ?string
314 |     {
315 |         $projectDir = $this->getProjectDir();
316 | 
317 |         if (null === $projectDir) {
318 |             return null;
319 |         }
320 | 
321 |         $composerFilePath = $projectDir.'/composer.json';
322 | 
323 |         if (!file_exists($composerFilePath)) {
324 |             return null;
325 |         }
326 | 
327 |         /** @var array{extra: array{string, string}} $composerConfig */
328 |         $composerConfig = json_decode(file_get_contents($composerFilePath) ?: '', true);
329 | 
330 |         return $composerConfig['extra'][$dir] ?? null;
331 |     }
332 | 
333 |     /**
334 |      * Gets the kernel instance from the application.
335 |      *
336 |      * @return KernelInterface|null The Symfony kernel or null if not available
337 |      */
338 |     private function getKernel(): ?KernelInterface
339 |     {
340 |         $application = $this->getApplication();
341 | 
342 |         if (!$application instanceof Application) {
343 |             return null;
344 |         }
345 | 
346 |         return $application->getKernel();
347 |     }
348 | }
349 | 


--------------------------------------------------------------------------------
/Component/FlasherComponent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Flasher\Symfony\Component;
 6 | 
 7 | /**
 8 |  * FlasherComponent - Twig component for rendering notifications.
 9 |  *
10 |  * This class implements a Twig component that can be used in templates to render
11 |  * PHPFlasher notifications. It supports customizing the filtering criteria,
12 |  * presenter format, and rendering context.
13 |  *
14 |  * Design patterns:
15 |  * - Component-based Architecture: Implements Twig's component pattern
16 |  * - Data Transfer Object: Holds configuration for notification rendering
17 |  *
18 |  * Usage in templates:
19 |  * ```twig
20 |  * <twig:flasher
21 |  *   criteria="{{ {limit: 5} }}"
22 |  *   presenter="html"
23 |  *   context="{{ {foo: 'bar'} }}" />
24 |  * ```
25 |  */
26 | final class FlasherComponent
27 | {
28 |     /**
29 |      * Filtering criteria for notifications.
30 |      *
31 |      * @var array<string, mixed>
32 |      */
33 |     public array $criteria = [];
34 | 
35 |     /**
36 |      * Presentation format (e.g., 'html', 'json').
37 |      */
38 |     public string $presenter = 'html';
39 | 
40 |     /**
41 |      * Additional context for rendering.
42 |      *
43 |      * @var array<string, mixed>
44 |      */
45 |     public array $context = [];
46 | }
47 | 


--------------------------------------------------------------------------------
/DependencyInjection/Compiler/EventListenerCompilerPass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Flasher\Symfony\DependencyInjection\Compiler;
 6 | 
 7 | use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 8 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 9 | use Symfony\Component\DependencyInjection\Reference;
10 | 
11 | /**
12 |  * EventListenerCompilerPass - Registers event listeners with the event dispatcher.
13 |  *
14 |  * This compiler pass finds all services tagged with 'flasher.event_listener'
15 |  * and registers them with the PHPFlasher event dispatcher. This allows for
16 |  * automatic discovery and registration of event listeners.
17 |  *
18 |  * Design patterns:
19 |  * - Compiler Pass: Modifies container definitions during compilation
20 |  * - Service Discovery: Automatically discovers tagged services
21 |  * - Observer Pattern: Helps set up the event dispatch/observer system
22 |  */
23 | final class EventListenerCompilerPass implements CompilerPassInterface
24 | {
25 |     /**
26 |      * Process the container to register event listeners.
27 |      *
28 |      * @param ContainerBuilder $container The service container builder
29 |      */
30 |     public function process(ContainerBuilder $container): void
31 |     {
32 |         $definition = $container->findDefinition('flasher.event_dispatcher');
33 | 
34 |         foreach (array_keys($container->findTaggedServiceIds('flasher.event_listener')) as $id) {
35 |             $definition->addMethodCall('addListener', [new Reference($id)]);
36 |         }
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/DependencyInjection/Compiler/PresenterCompilerPass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Flasher\Symfony\DependencyInjection\Compiler;
 6 | 
 7 | use Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument;
 8 | use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 9 | use Symfony\Component\DependencyInjection\ContainerBuilder;
10 | use Symfony\Component\DependencyInjection\Reference;
11 | 
12 | /**
13 |  * PresenterCompilerPass - Registers response presenters with the response manager.
14 |  *
15 |  * This compiler pass finds all services tagged with 'flasher.presenter'
16 |  * and registers them with the PHPFlasher response manager. This allows for
17 |  * automatic discovery and registration of response presenters.
18 |  *
19 |  * Design patterns:
20 |  * - Compiler Pass: Modifies container definitions during compilation
21 |  * - Service Discovery: Automatically discovers tagged services
22 |  * - Strategy Pattern: Helps set up pluggable response presentation strategies
23 |  */
24 | final class PresenterCompilerPass implements CompilerPassInterface
25 | {
26 |     /**
27 |      * Process the container to register presenters.
28 |      *
29 |      * @param ContainerBuilder $container The service container builder
30 |      */
31 |     public function process(ContainerBuilder $container): void
32 |     {
33 |         $definition = $container->findDefinition('flasher.response_manager');
34 | 
35 |         foreach ($container->findTaggedServiceIds('flasher.presenter') as $id => $tags) {
36 |             foreach ($tags as $attributes) {
37 |                 $definition->addMethodCall('addPresenter', [
38 |                     $attributes['alias'],
39 |                     new ServiceClosureArgument(new Reference($id)),
40 |                 ]);
41 |             }
42 |         }
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/DependencyInjection/Configuration.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Flasher\Symfony\DependencyInjection;
  6 | 
  7 | use Flasher\Prime\Plugin\FlasherPlugin;
  8 | use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
  9 | use Symfony\Component\Config\Definition\Builder\TreeBuilder;
 10 | use Symfony\Component\Config\Definition\ConfigurationInterface;
 11 | 
 12 | final readonly class Configuration implements ConfigurationInterface
 13 | {
 14 |     public function __construct(private FlasherPlugin $plugin)
 15 |     {
 16 |     }
 17 | 
 18 |     public function getConfigTreeBuilder(): TreeBuilder
 19 |     {
 20 |         $treeBuilder = new TreeBuilder($this->plugin->getName());
 21 |         $rootNode = $treeBuilder->getRootNode();
 22 | 
 23 |         $this->normalizeConfig($rootNode);
 24 | 
 25 |         $this->addGeneralSection($rootNode);
 26 |         $this->addFlashBagSection($rootNode);
 27 |         $this->addPresetsSection($rootNode);
 28 |         $this->addPluginsSection($rootNode);
 29 | 
 30 |         return $treeBuilder;
 31 |     }
 32 | 
 33 |     private function normalizeConfig(ArrayNodeDefinition $rootNode): void
 34 |     {
 35 |         $rootNode
 36 |             ->beforeNormalization()
 37 |                 ->always(fn ($v): array => $this->plugin->normalizeConfig($v))
 38 |             ->end();
 39 |     }
 40 | 
 41 |     private function addGeneralSection(ArrayNodeDefinition $rootNode): void
 42 |     {
 43 |         $rootNode
 44 |             ->children()
 45 |                 ->scalarNode('default')
 46 |                     ->info('Default notification library (e.g., "flasher", "toastr", "noty", "notyf", "sweetalert")')
 47 |                     ->isRequired()
 48 |                     ->cannotBeEmpty()
 49 |                     ->defaultValue($this->plugin->getDefault())
 50 |                 ->end()
 51 |                 ->scalarNode('main_script')
 52 |                     ->info('Path to the main PHPFlasher JavaScript file')
 53 |                     ->defaultValue($this->plugin->getRootScript())
 54 |                 ->end()
 55 |                 ->booleanNode('inject_assets')
 56 |                     ->info('Automatically inject assets into HTML pages')
 57 |                     ->defaultTrue()
 58 |                 ->end()
 59 |                 ->booleanNode('translate')
 60 |                     ->info('Enable message translation')
 61 |                     ->defaultTrue()
 62 |                 ->end()
 63 |                 ->arrayNode('excluded_paths')
 64 |                     ->info('URL patterns to exclude from asset injection and flash_bag conversion')
 65 |                     ->defaultValue([
 66 |                         '/^\/_profiler/',
 67 |                         '/^\/_fragment/',
 68 |                     ])
 69 |                     ->scalarPrototype()->end()
 70 |                 ->end()
 71 |                 ->arrayNode('filter')
 72 |                     ->info('Criteria to filter notifications')
 73 |                     ->variablePrototype()->end()
 74 |                 ->end()
 75 |                 ->arrayNode('scripts')
 76 |                     ->info('Additional JavaScript files')
 77 |                     ->performNoDeepMerging()
 78 |                     ->scalarPrototype()->end()
 79 |                 ->end()
 80 |                 ->arrayNode('styles')
 81 |                     ->info('CSS files to style notifications')
 82 |                     ->performNoDeepMerging()
 83 |                     ->scalarPrototype()->end()
 84 |                 ->end()
 85 |                 ->arrayNode('options')
 86 |                     ->info('Global notification options')
 87 |                     ->variablePrototype()->end()
 88 |                 ->end()
 89 |             ->end();
 90 |     }
 91 | 
 92 |     private function addFlashBagSection(ArrayNodeDefinition $rootNode): void
 93 |     {
 94 |         $rootNode
 95 |             ->children()
 96 |                 ->variableNode('flash_bag')
 97 |                     ->info('Map Symfony flash messages to notification types')
 98 |                     ->defaultTrue()
 99 |                 ->end()
100 |             ->end();
101 |     }
102 | 
103 |     private function addPresetsSection(ArrayNodeDefinition $rootNode): void
104 |     {
105 |         $rootNode
106 |             ->fixXmlConfig('preset')
107 |             ->children()
108 |                 ->arrayNode('presets')
109 |                     ->info('Notification presets (optional)')
110 |                     ->useAttributeAsKey('name')
111 |                     ->arrayPrototype()
112 |                         ->children()
113 |                             ->scalarNode('type')
114 |                                 ->info('Notification type (e.g., "success", "error")')
115 |                             ->end()
116 |                             ->scalarNode('title')
117 |                                 ->info('Default title')
118 |                             ->end()
119 |                             ->scalarNode('message')
120 |                                 ->info('Default message')
121 |                             ->end()
122 |                             ->arrayNode('options')
123 |                                 ->info('Additional options')
124 |                                 ->variablePrototype()->end()
125 |                             ->end()
126 |                         ->end()
127 |                     ->end()
128 |                 ->end()
129 |             ->end();
130 |     }
131 | 
132 |     private function addPluginsSection(ArrayNodeDefinition $rootNode): void
133 |     {
134 |         $rootNode
135 |             ->fixXmlConfig('plugin')
136 |             ->children()
137 |                 ->arrayNode('plugins')
138 |                     ->info('Additional plugins')
139 |                     ->useAttributeAsKey('name')
140 |                     ->arrayPrototype()
141 |                         ->children()
142 |                             ->scalarNode('view')
143 |                                 ->info('Custom twig view template')
144 |                             ->end()
145 |                             ->arrayNode('styles')
146 |                                 ->info('CSS files for the plugin')
147 |                                 ->performNoDeepMerging()
148 |                                 ->scalarPrototype()->end()
149 |                             ->end()
150 |                             ->arrayNode('scripts')
151 |                                 ->info('JavaScript files for the plugin')
152 |                                 ->performNoDeepMerging()
153 |                                 ->scalarPrototype()->end()
154 |                             ->end()
155 |                             ->arrayNode('options')
156 |                                 ->info('Plugin-specific options')
157 |                                 ->variablePrototype()->end()
158 |                             ->end()
159 |                         ->end()
160 |                     ->end()
161 |                 ->end()
162 |             ->end();
163 |     }
164 | }
165 | 


--------------------------------------------------------------------------------
/DependencyInjection/FlasherExtension.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Flasher\Symfony\DependencyInjection;
  6 | 
  7 | use Flasher\Prime\EventDispatcher\EventListener\EventListenerInterface;
  8 | use Flasher\Prime\Plugin\FlasherPlugin;
  9 | use Flasher\Prime\Storage\Bag\ArrayBag;
 10 | use Flasher\Symfony\Attribute\AsFlasherFactory;
 11 | use Flasher\Symfony\Attribute\AsFlasherPresenter;
 12 | use Symfony\Component\Config\Definition\ConfigurationInterface;
 13 | use Symfony\Component\DependencyInjection\ChildDefinition;
 14 | use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 15 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 16 | use Symfony\Component\DependencyInjection\Extension\AbstractExtension;
 17 | use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
 18 | 
 19 | final class FlasherExtension extends AbstractExtension implements CompilerPassInterface
 20 | {
 21 |     public function __construct(private readonly FlasherPlugin $plugin)
 22 |     {
 23 |     }
 24 | 
 25 |     public function getAlias(): string
 26 |     {
 27 |         return $this->plugin->getName();
 28 |     }
 29 | 
 30 |     /**
 31 |      * @param array<string, mixed> $config
 32 |      */
 33 |     public function getConfiguration(array $config, ContainerBuilder $container): ConfigurationInterface
 34 |     {
 35 |         return new Configuration($this->plugin);
 36 |     }
 37 | 
 38 |     /**
 39 |      * @param array{
 40 |      *     default: string,
 41 |      *     main_script: string,
 42 |      *     inject_assets: bool,
 43 |      *     excluded_paths: list<non-empty-string>,
 44 |      *     presets: array<string, mixed>,
 45 |      *     flash_bag: array<string, mixed>,
 46 |      *     filter: array<string, mixed>,
 47 |      *     plugins: array<array<string, mixed>>,
 48 |      * } $config
 49 |      */
 50 |     public function loadExtension(array $config, ContainerConfigurator $container, ContainerBuilder $builder): void
 51 |     {
 52 |         $this->registerFlasherParameters($config, $container, $builder);
 53 |         $this->registerServicesForAutoconfiguration($builder);
 54 | 
 55 |         $container->import(__DIR__.'/../Resources/config/services.php');
 56 |     }
 57 | 
 58 |     public function process(ContainerBuilder $container): void
 59 |     {
 60 |         $this->registerFlasherTranslator($container);
 61 |         $this->configureSessionServices($container);
 62 |         $this->configureFlasherListener($container);
 63 |     }
 64 | 
 65 |     /**
 66 |      * @param array{
 67 |      *     default: string,
 68 |      *     main_script: string,
 69 |      *     inject_assets: bool,
 70 |      *     excluded_paths: list<non-empty-string>,
 71 |      *     presets: array<string, mixed>,
 72 |      *     flash_bag: array<string, mixed>,
 73 |      *     filter: array<string, mixed>,
 74 |      *     plugins: array<array<string, mixed>>,
 75 |      * } $config
 76 |      */
 77 |     private function registerFlasherParameters(array $config, ContainerConfigurator $container, ContainerBuilder $builder): void
 78 |     {
 79 |         /** @var string $projectDir */
 80 |         $projectDir = $builder->getParameter('kernel.project_dir');
 81 |         $publicDir = $projectDir.\DIRECTORY_SEPARATOR.'public';
 82 |         $assetsDir = $publicDir.\DIRECTORY_SEPARATOR.'vendor'.\DIRECTORY_SEPARATOR.'flasher';
 83 |         $manifestPath = $assetsDir.\DIRECTORY_SEPARATOR.'manifest.json';
 84 | 
 85 |         $container->parameters()
 86 |             ->set('flasher', $config)
 87 |             ->set('flasher.public_dir', $publicDir)
 88 |             ->set('flasher.assets_dir', $assetsDir)
 89 |             ->set('flasher.json_manifest_path', $manifestPath)
 90 |             ->set('flasher.default', $config['default'])
 91 |             ->set('flasher.main_script', $config['main_script'])
 92 |             ->set('flasher.inject_assets', $config['inject_assets'])
 93 |             ->set('flasher.excluded_paths', $config['excluded_paths'])
 94 |             ->set('flasher.flash_bag', $config['flash_bag'])
 95 |             ->set('flasher.filter', $config['filter'])
 96 |             ->set('flasher.presets', $config['presets'])
 97 |             ->set('flasher.plugins', $config['plugins'])
 98 |         ;
 99 |     }
100 | 
101 |     private function registerServicesForAutoconfiguration(ContainerBuilder $builder): void
102 |     {
103 |         $builder->registerForAutoconfiguration(EventListenerInterface::class)
104 |             ->addTag('flasher.event_listener');
105 | 
106 |         $builder->registerAttributeForAutoconfiguration(AsFlasherFactory::class, static function (ChildDefinition $definition, AsFlasherFactory $attribute): void {
107 |             $definition->addTag('flasher.factory', get_object_vars($attribute));
108 |         });
109 | 
110 |         $builder->registerAttributeForAutoconfiguration(AsFlasherPresenter::class, static function (ChildDefinition $definition, AsFlasherPresenter $attribute): void {
111 |             $definition->addTag('flasher.presenter', get_object_vars($attribute));
112 |         });
113 |     }
114 | 
115 |     private function registerFlasherTranslator(ContainerBuilder $container): void
116 |     {
117 |         if ($container->has('translator')) {
118 |             return;
119 |         }
120 | 
121 |         $container->removeDefinition('flasher.translator');
122 |     }
123 | 
124 |     private function configureSessionServices(ContainerBuilder $container): void
125 |     {
126 |         if (!$container->has('session.factory') || false === $container->getParameter('flasher.flash_bag')) {
127 |             $container->removeDefinition('flasher.session_listener');
128 |         }
129 | 
130 |         if (!$container->has('session.factory')) {
131 |             $container->removeDefinition('flasher.storage_bag');
132 |             $container->register('flasher.storage_bag', ArrayBag::class);
133 |         }
134 |     }
135 | 
136 |     private function configureFlasherListener(ContainerBuilder $container): void
137 |     {
138 |         if ($container->getParameter('flasher.inject_assets')) {
139 |             return;
140 |         }
141 | 
142 |         $container->removeDefinition('flasher.flasher_listener');
143 |     }
144 | }
145 | 


--------------------------------------------------------------------------------
/EventListener/FlasherListener.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Flasher\Symfony\EventListener;
 6 | 
 7 | use Flasher\Prime\Http\ResponseExtensionInterface;
 8 | use Flasher\Symfony\Http\Request;
 9 | use Flasher\Symfony\Http\Response;
10 | use Symfony\Component\EventDispatcher\EventSubscriberInterface;
11 | use Symfony\Component\HttpKernel\Event\ResponseEvent;
12 | 
13 | /**
14 |  * FlasherListener - Injects PHPFlasher assets into responses.
15 |  *
16 |  * This event subscriber listens for kernel.response events and injects
17 |  * PHPFlasher JavaScript and CSS assets into appropriate HTTP responses.
18 |  * It adapts Symfony's request and response objects to PHPFlasher's interfaces.
19 |  *
20 |  * Design patterns:
21 |  * - Observer Pattern: Observes Symfony's kernel events
22 |  * - Adapter Pattern: Adapts Symfony's request/response to PHPFlasher's interfaces
23 |  * - Event Subscriber: Subscribes to Symfony's event dispatcher system
24 |  */
25 | final readonly class FlasherListener implements EventSubscriberInterface
26 | {
27 |     /**
28 |      * Creates a new FlasherListener instance.
29 |      *
30 |      * @param ResponseExtensionInterface $responseExtension Service for extending responses with notifications
31 |      */
32 |     public function __construct(private ResponseExtensionInterface $responseExtension)
33 |     {
34 |     }
35 | 
36 |     /**
37 |      * Processes the response to inject PHPFlasher assets.
38 |      *
39 |      * This handler adapts Symfony's request and response objects to PHPFlasher's
40 |      * interfaces, then delegates to the response extension for asset injection.
41 |      *
42 |      * @param ResponseEvent $event The response event
43 |      */
44 |     public function onKernelResponse(ResponseEvent $event): void
45 |     {
46 |         $request = new Request($event->getRequest());
47 |         $response = new Response($event->getResponse());
48 | 
49 |         $this->responseExtension->render($request, $response);
50 |     }
51 | 
52 |     /**
53 |      * {@inheritdoc}
54 |      *
55 |      * Returns events this subscriber listens to and their corresponding handlers.
56 |      * The low priority (-20) ensures this runs after most other response listeners.
57 |      *
58 |      * @return array<string, array<int, int|string>> The events and handlers
59 |      */
60 |     public static function getSubscribedEvents(): array
61 |     {
62 |         return [
63 |             ResponseEvent::class => ['onKernelResponse', -20],
64 |         ];
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/EventListener/SessionListener.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Flasher\Symfony\EventListener;
 6 | 
 7 | use Flasher\Prime\Http\RequestExtensionInterface;
 8 | use Flasher\Symfony\Http\Request;
 9 | use Flasher\Symfony\Http\Response;
10 | use Symfony\Component\EventDispatcher\EventSubscriberInterface;
11 | use Symfony\Component\HttpKernel\Event\ResponseEvent;
12 | 
13 | /**
14 |  * SessionListener - Processes session flash messages.
15 |  *
16 |  * This event subscriber listens for kernel.response events and converts
17 |  * Symfony's session flash messages to PHPFlasher notifications. This enables
18 |  * PHPFlasher to work with existing code that uses Symfony's flash messaging.
19 |  *
20 |  * Design patterns:
21 |  * - Observer Pattern: Observes Symfony's kernel events
22 |  * - Adapter Pattern: Adapts Symfony's flash messages to PHPFlasher notifications
23 |  * - Transformer Pattern: Transforms data from one format to another
24 |  */
25 | final readonly class SessionListener implements EventSubscriberInterface
26 | {
27 |     /**
28 |      * Creates a new SessionListener instance.
29 |      *
30 |      * @param RequestExtensionInterface $requestExtension Service for processing request flash messages
31 |      */
32 |     public function __construct(private RequestExtensionInterface $requestExtension)
33 |     {
34 |     }
35 | 
36 |     /**
37 |      * Processes the request to convert flash messages to notifications.
38 |      *
39 |      * This handler adapts Symfony's request and response objects to PHPFlasher's
40 |      * interfaces, then delegates to the request extension for flash processing.
41 |      *
42 |      * @param ResponseEvent $event The response event
43 |      */
44 |     public function onKernelResponse(ResponseEvent $event): void
45 |     {
46 |         $request = new Request($event->getRequest());
47 |         $response = new Response($event->getResponse());
48 | 
49 |         $this->requestExtension->flash($request, $response);
50 |     }
51 | 
52 |     /**
53 |      * {@inheritdoc}
54 |      *
55 |      * Returns events this subscriber listens to and their corresponding handlers.
56 |      *
57 |      * @return array<string, array<int, int|string>> The events and handlers
58 |      */
59 |     public static function getSubscribedEvents(): array
60 |     {
61 |         return [
62 |             ResponseEvent::class => ['onKernelResponse', 0],
63 |         ];
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/Factory/NotificationFactoryLocator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Flasher\Symfony\Factory;
 6 | 
 7 | use Flasher\Prime\Factory\NotificationFactoryInterface;
 8 | use Flasher\Prime\Factory\NotificationFactoryLocatorInterface;
 9 | use Symfony\Component\DependencyInjection\ServiceLocator;
10 | 
11 | /**
12 |  * NotificationFactoryLocator - Locator for notification factories using Symfony's ServiceLocator.
13 |  *
14 |  * This class adapts Symfony's ServiceLocator to PHPFlasher's NotificationFactoryLocatorInterface,
15 |  * enabling runtime discovery and lazy-loading of notification factories.
16 |  *
17 |  * Design patterns:
18 |  * - Adapter Pattern: Adapts Symfony's ServiceLocator to PHPFlasher's interface
19 |  * - Service Locator Pattern: Provides unified access to notification factory services
20 |  * - Lazy Loading: Services are only instantiated when requested
21 |  */
22 | final readonly class NotificationFactoryLocator implements NotificationFactoryLocatorInterface
23 | {
24 |     /**
25 |      * Creates a new NotificationFactoryLocator instance.
26 |      *
27 |      * @param ServiceLocator<NotificationFactoryInterface> $serviceLocator Symfony's service locator
28 |      */
29 |     public function __construct(private ServiceLocator $serviceLocator)
30 |     {
31 |     }
32 | 
33 |     /**
34 |      * {@inheritdoc}
35 |      *
36 |      * Checks if a notification factory with the given ID exists.
37 |      *
38 |      * @param string $id The factory identifier
39 |      *
40 |      * @return bool True if the factory exists, false otherwise
41 |      */
42 |     public function has(string $id): bool
43 |     {
44 |         return $this->serviceLocator->has($id);
45 |     }
46 | 
47 |     /**
48 |      * {@inheritdoc}
49 |      *
50 |      * Gets a notification factory by ID.
51 |      *
52 |      * @param string $id The factory identifier
53 |      *
54 |      * @return NotificationFactoryInterface The notification factory
55 |      */
56 |     public function get(string $id): NotificationFactoryInterface
57 |     {
58 |         return $this->serviceLocator->get($id);
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/FlasherSymfonyBundle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Flasher\Symfony;
 6 | 
 7 | use Flasher\Prime\Container\FlasherContainer;
 8 | use Flasher\Prime\Plugin\FlasherPlugin;
 9 | use Flasher\Symfony\DependencyInjection\Compiler\EventListenerCompilerPass;
10 | use Flasher\Symfony\DependencyInjection\Compiler\PresenterCompilerPass;
11 | use Flasher\Symfony\DependencyInjection\FlasherExtension;
12 | use Psr\Container\ContainerInterface;
13 | use Symfony\Component\DependencyInjection\ContainerBuilder;
14 | use Symfony\Component\DependencyInjection\Extension\ExtensionInterface;
15 | 
16 | /**
17 |  * FlasherSymfonyBundle - Main bundle for PHPFlasher Symfony integration.
18 |  *
19 |  * This bundle serves as the entry point for integrating PHPFlasher with Symfony.
20 |  * It registers compiler passes, configures the container extension, and sets up
21 |  * the global container instance for PHPFlasher.
22 |  *
23 |  * Design patterns:
24 |  * - Bundle: Implements Symfony's bundle pattern for packaging functionality
25 |  * - Registry: Sets up the container registry for PHPFlasher
26 |  * - Extension: Extends the base plugin bundle with PHPFlasher-specific functionality
27 |  */
28 | final class FlasherSymfonyBundle extends Support\PluginBundle // Symfony\Component\HttpKernel\Bundle\Bundle
29 | {
30 |     /**
31 |      * Set up the global container reference when the bundle boots.
32 |      *
33 |      * This allows PHPFlasher to access services from Symfony's container.
34 |      */
35 |     public function boot(): void
36 |     {
37 |         if ($this->container instanceof ContainerInterface) {
38 |             FlasherContainer::from($this->container);
39 |         }
40 |     }
41 | 
42 |     /**
43 |      * Register compiler passes with the container.
44 |      *
45 |      * @param ContainerBuilder $container The container builder
46 |      */
47 |     public function build(ContainerBuilder $container): void
48 |     {
49 |         $container->addCompilerPass(new EventListenerCompilerPass());
50 |         $container->addCompilerPass(new PresenterCompilerPass());
51 |     }
52 | 
53 |     /**
54 |      * Get the container extension for this bundle.
55 |      *
56 |      * @return ExtensionInterface The bundle extension
57 |      */
58 |     public function getContainerExtension(): ExtensionInterface
59 |     {
60 |         return new FlasherExtension($this->createPlugin());
61 |     }
62 | 
63 |     /**
64 |      * Create the core PHPFlasher plugin.
65 |      *
66 |      * @return FlasherPlugin The core PHPFlasher plugin
67 |      */
68 |     public function createPlugin(): FlasherPlugin
69 |     {
70 |         return new FlasherPlugin();
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/Http/Request.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Flasher\Symfony\Http;
  6 | 
  7 | use Flasher\Prime\Http\RequestInterface;
  8 | use Symfony\Component\HttpFoundation\Exception\SessionNotFoundException;
  9 | use Symfony\Component\HttpFoundation\Request as SymfonyRequest;
 10 | use Symfony\Component\HttpFoundation\Session\FlashBagAwareSessionInterface;
 11 | use Symfony\Component\HttpFoundation\Session\SessionInterface;
 12 | 
 13 | /**
 14 |  * Request - Adapter for Symfony's HTTP request.
 15 |  *
 16 |  * This class implements PHPFlasher's RequestInterface for Symfony's HTTP request,
 17 |  * providing a consistent interface for request inspection and session interaction
 18 |  * regardless of the underlying framework.
 19 |  *
 20 |  * Design patterns:
 21 |  * - Adapter Pattern: Adapts framework-specific request to PHPFlasher's interface
 22 |  * - Decorator Pattern: Adds PHPFlasher-specific functionality to request objects
 23 |  * - Null Object Pattern: Gracefully handles missing sessions
 24 |  */
 25 | final readonly class Request implements RequestInterface
 26 | {
 27 |     /**
 28 |      * Creates a new Request adapter.
 29 |      *
 30 |      * @param SymfonyRequest $request The underlying Symfony request object
 31 |      */
 32 |     public function __construct(private SymfonyRequest $request)
 33 |     {
 34 |     }
 35 | 
 36 |     public function getUri(): string
 37 |     {
 38 |         return $this->request->getRequestUri();
 39 |     }
 40 | 
 41 |     public function isXmlHttpRequest(): bool
 42 |     {
 43 |         return $this->request->isXmlHttpRequest();
 44 |     }
 45 | 
 46 |     public function isHtmlRequestFormat(): bool
 47 |     {
 48 |         return 'html' === $this->request->getRequestFormat();
 49 |     }
 50 | 
 51 |     public function hasSession(): bool
 52 |     {
 53 |         return $this->request->hasSession();
 54 |     }
 55 | 
 56 |     public function isSessionStarted(): bool
 57 |     {
 58 |         $session = $this->getSession();
 59 | 
 60 |         return $session?->isStarted() ?: false;
 61 |     }
 62 | 
 63 |     public function hasType(string $type): bool
 64 |     {
 65 |         if (!$this->hasSession() || !$this->isSessionStarted()) {
 66 |             return false;
 67 |         }
 68 | 
 69 |         $session = $this->getSession();
 70 |         if (!$session instanceof FlashBagAwareSessionInterface) {
 71 |             return false;
 72 |         }
 73 | 
 74 |         return $session->getFlashBag()->has($type);
 75 |     }
 76 | 
 77 |     /**
 78 |      * @return string[]
 79 |      */
 80 |     public function getType(string $type): array
 81 |     {
 82 |         $session = $this->getSession();
 83 |         if (!$session instanceof FlashBagAwareSessionInterface) {
 84 |             return [];
 85 |         }
 86 | 
 87 |         return $session->getFlashBag()->get($type);
 88 |     }
 89 | 
 90 |     public function forgetType(string $type): void
 91 |     {
 92 |         $this->getType($type);
 93 |     }
 94 | 
 95 |     /**
 96 |      * Gets the session from the request, with graceful handling of missing sessions.
 97 |      *
 98 |      * @return SessionInterface|null The session or null if not available
 99 |      */
100 |     private function getSession(): ?SessionInterface
101 |     {
102 |         try {
103 |             return $this->request->getSession();
104 |         } catch (SessionNotFoundException) {
105 |             return null;
106 |         }
107 |     }
108 | 
109 |     public function hasHeader(string $key): bool
110 |     {
111 |         return $this->request->headers->has($key);
112 |     }
113 | 
114 |     public function getHeader(string $key): ?string
115 |     {
116 |         return $this->request->headers->get($key);
117 |     }
118 | }
119 | 


--------------------------------------------------------------------------------
/Http/Response.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Flasher\Symfony\Http;
  6 | 
  7 | use Flasher\Prime\Http\ResponseInterface;
  8 | use Symfony\Component\HttpFoundation\JsonResponse;
  9 | use Symfony\Component\HttpFoundation\Response as SymfonyResponse;
 10 | 
 11 | /**
 12 |  * Response - Adapter for Symfony's HTTP response.
 13 |  *
 14 |  * This class implements PHPFlasher's ResponseInterface for Symfony's HTTP response,
 15 |  * providing a consistent interface for response manipulation regardless of the framework.
 16 |  * It allows PHPFlasher to work with Symfony responses in a framework-agnostic way.
 17 |  *
 18 |  * Design patterns:
 19 |  * - Adapter Pattern: Adapts framework-specific response to PHPFlasher's interface
 20 |  * - Decorator Pattern: Adds PHPFlasher-specific functionality to response objects
 21 |  * - Composition: Uses composition to delegate to the underlying response object
 22 |  */
 23 | final readonly class Response implements ResponseInterface
 24 | {
 25 |     /**
 26 |      * Creates a new Response adapter.
 27 |      *
 28 |      * @param SymfonyResponse $response The underlying Symfony response object
 29 |      */
 30 |     public function __construct(private SymfonyResponse $response)
 31 |     {
 32 |     }
 33 | 
 34 |     public function isRedirection(): bool
 35 |     {
 36 |         return $this->response->isRedirection();
 37 |     }
 38 | 
 39 |     public function isJson(): bool
 40 |     {
 41 |         return $this->response instanceof JsonResponse;
 42 |     }
 43 | 
 44 |     public function isHtml(): bool
 45 |     {
 46 |         $contentType = $this->response->headers->get('Content-Type');
 47 | 
 48 |         if (!\is_string($contentType)) {
 49 |             return false;
 50 |         }
 51 | 
 52 |         return false !== stripos($contentType, 'html');
 53 |     }
 54 | 
 55 |     public function isAttachment(): bool
 56 |     {
 57 |         $contentDisposition = $this->response->headers->get('Content-Disposition', '');
 58 | 
 59 |         if (!$contentDisposition) {
 60 |             return false;
 61 |         }
 62 | 
 63 |         return false !== stripos($contentDisposition, 'attachment;');
 64 |     }
 65 | 
 66 |     public function isSuccessful(): bool
 67 |     {
 68 |         return $this->response->isSuccessful();
 69 |     }
 70 | 
 71 |     public function getContent(): string
 72 |     {
 73 |         return $this->response->getContent() ?: '';
 74 |     }
 75 | 
 76 |     public function setContent(string $content): void
 77 |     {
 78 |         $this->response->setContent($content);
 79 |     }
 80 | 
 81 |     public function hasHeader(string $key): bool
 82 |     {
 83 |         return $this->response->headers->has($key);
 84 |     }
 85 | 
 86 |     public function getHeader(string $key): ?string
 87 |     {
 88 |         return $this->response->headers->get($key);
 89 |     }
 90 | 
 91 |     public function setHeader(string $key, array|string|null $values): void
 92 |     {
 93 |         $this->response->headers->set($key, $values);
 94 |     }
 95 | 
 96 |     public function removeHeader(string $key): void
 97 |     {
 98 |         $this->response->headers->remove($key);
 99 |     }
100 | }
101 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2024 PHPFlasher
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Profiler/FlasherDataCollector.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Flasher\Symfony\Profiler;
  6 | 
  7 | use Flasher\Prime\EventDispatcher\EventListener\NotificationLoggerListener;
  8 | use Flasher\Prime\Flasher;
  9 | use Flasher\Prime\Notification\Envelope;
 10 | use Symfony\Bundle\FrameworkBundle\DataCollector\AbstractDataCollector;
 11 | use Symfony\Component\HttpFoundation\Request;
 12 | use Symfony\Component\HttpFoundation\Response;
 13 | use Symfony\Component\HttpKernel\DataCollector\LateDataCollectorInterface;
 14 | use Symfony\Component\HttpKernel\Kernel;
 15 | use Symfony\Component\VarDumper\Cloner\Data;
 16 | 
 17 | /**
 18 |  * FlasherDataCollector - Collects PHPFlasher data for the Symfony profiler.
 19 |  *
 20 |  * This data collector captures information about PHPFlasher notifications,
 21 |  * both dispatched and displayed, for the Symfony web profiler. It also collects
 22 |  * configuration and version information.
 23 |  *
 24 |  * Design patterns:
 25 |  * - Data Collector: Implements Symfony's data collector pattern for profiling
 26 |  * - Late Collection: Collects data after a request is completed
 27 |  * - Type Safety: Uses PHPDoc annotations for complex type declarations
 28 |  *
 29 |  * @phpstan-type NotificationShape array{
 30 |  *     title: string,
 31 |  *     message: string,
 32 |  *     type: string,
 33 |  *     options: array<string, mixed>,
 34 |  *     metadata: array<string, mixed>,
 35 |  * }
 36 |  * @phpstan-type ConfigShare array{
 37 |  *     default: string,
 38 |  *     main_script: string,
 39 |  *     inject_assets: bool,
 40 |  *     excluded_paths: list<non-empty-string>,
 41 |  *     presets: array<string, mixed>,
 42 |  *     flash_bag: array<string, mixed>,
 43 |  *     filter: array{limit?: int|null},
 44 |  *     plugins: array<array<string, mixed>>,
 45 |  * }
 46 |  * @phpstan-type DataShape array{
 47 |  *     displayed_envelopes: NotificationShape[],
 48 |  *     dispatched_envelopes: NotificationShape[],
 49 |  *     config: array<string, mixed>,
 50 |  *     versions: array{
 51 |  *         php_flasher: string,
 52 |  *         php: string,
 53 |  *         symfony: string
 54 |  *     }
 55 |  * }
 56 |  *
 57 |  * @property DataShape|Data<DataShape> $data
 58 |  *
 59 |  * @internal
 60 |  */
 61 | #[\AllowDynamicProperties]
 62 | final class FlasherDataCollector extends AbstractDataCollector implements LateDataCollectorInterface
 63 | {
 64 |     /**
 65 |      * Creates a new FlasherDataCollector instance.
 66 |      *
 67 |      * @param NotificationLoggerListener $logger The notification logger for accessing dispatched notifications
 68 |      * @param array<string, mixed>       $config The PHPFlasher configuration
 69 |      *
 70 |      * @phpstan-param ConfigShare $config
 71 |      */
 72 |     public function __construct(
 73 |         private readonly NotificationLoggerListener $logger,
 74 |         private readonly array $config,
 75 |     ) {
 76 |     }
 77 | 
 78 |     /**
 79 |      * Initial data collection - called during request processing.
 80 |      *
 81 |      * This implementation doesn't collect data here, deferring to lateCollect.
 82 |      *
 83 |      * @param Request         $request   The request object
 84 |      * @param Response        $response  The response object
 85 |      * @param \Throwable|null $exception Any exception that occurred
 86 |      */
 87 |     public function collect(Request $request, Response $response, ?\Throwable $exception = null): void
 88 |     {
 89 |         // No action needed here since we're collecting data in lateCollect
 90 |     }
 91 | 
 92 |     /**
 93 |      * Late data collection - called after response is sent.
 94 |      *
 95 |      * Collects information about notifications, configuration, and versions.
 96 |      */
 97 |     public function lateCollect(): void
 98 |     {
 99 |         $this->data = [
100 |             'displayed_envelopes' => array_map(fn (Envelope $envelope) => $envelope->toArray(), $this->logger->getDisplayedEnvelopes()->getEnvelopes()),
101 |             'dispatched_envelopes' => array_map(fn (Envelope $envelope) => $envelope->toArray(), $this->logger->getDispatchedEnvelopes()->getEnvelopes()),
102 |             'config' => $this->config,
103 |             'versions' => [
104 |                 'php_flasher' => Flasher::VERSION,
105 |                 'php' => \PHP_VERSION,
106 |                 'symfony' => Kernel::VERSION,
107 |             ],
108 |         ];
109 | 
110 |         $this->data = $this->cloneVar($this->data);
111 |     }
112 | 
113 |     /**
114 |      * Gets the collector data.
115 |      *
116 |      * @return DataShape|Data<DataShape>
117 |      */
118 |     public function getData(): array|Data
119 |     {
120 |         return $this->data;
121 |     }
122 | 
123 |     /**
124 |      * Gets the collector name for the profiler panel.
125 |      *
126 |      * @return string The collector name
127 |      */
128 |     public function getName(): string
129 |     {
130 |         return 'flasher';
131 |     }
132 | 
133 |     /**
134 |      * Resets the collector between requests when using kernel.reset.
135 |      */
136 |     public function reset(): void
137 |     {
138 |         $this->logger->reset();
139 |         parent::reset();
140 |     }
141 | 
142 |     /**
143 |      * Gets the displayed notification envelopes.
144 |      *
145 |      * @return NotificationShape[]|Data<NotificationShape>
146 |      */
147 |     public function getDisplayedEnvelopes(): array|Data
148 |     {
149 |         return $this->data['displayed_envelopes'] ?? [];
150 |     }
151 | 
152 |     /**
153 |      * Gets the dispatched notification envelopes.
154 |      *
155 |      * @return NotificationShape[]|Data<NotificationShape>
156 |      */
157 |     public function getDispatchedEnvelopes(): array|Data
158 |     {
159 |         return $this->data['dispatched_envelopes'] ?? [];
160 |     }
161 | 
162 |     /**
163 |      * Gets the PHPFlasher configuration.
164 |      *
165 |      * @phpstan-return ConfigShare|Data
166 |      */
167 |     public function getConfig(): array|Data
168 |     {
169 |         return $this->data['config'] ?? [];
170 |     }
171 | 
172 |     /**
173 |      * Gets version information.
174 |      *
175 |      * @return array{php_flasher: string, php: string, symfony: string}|Data
176 |      */
177 |     public function getVersions(): array|Data
178 |     {
179 |         return $this->data['versions'] ?? [];
180 |     }
181 | 
182 |     /**
183 |      * Gets the template path for the profiler panel.
184 |      *
185 |      * @return string The template path
186 |      */
187 |     public static function getTemplate(): string
188 |     {
189 |         return '@FlasherSymfony/profiler/flasher.html.twig';
190 |     }
191 | }
192 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | <div align="center">
  2 |     <a href="https://github.com/php-flasher/php-flasher/blob/2.x/docs/palestine.md">
  3 |         <img src="https://raw.githubusercontent.com/php-flasher/art/main/palestine-banner-support.svg" width="800px"  alt="Help Palestine"/>
  4 |     </a>
  5 | </div>
  6 | 
  7 | <p align="center">
  8 |     <picture>
  9 |       <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/php-flasher/art/main/php-flasher-logo-dark.png">
 10 |       <img src="https://raw.githubusercontent.com/php-flasher/art/main/php-flasher-logo.png" alt="PHPFlasher Logo">
 11 |     </picture>
 12 | </p>
 13 | 
 14 | <p align="center">
 15 |     <a href="https://www.linkedin.com/in/younes--ennaji"><img src="https://img.shields.io/badge/author-@yoeunes-blue.svg" alt="Author Badge"></a>
 16 |     <a href="https://github.com/php-flasher/php-flasher"><img src="https://img.shields.io/badge/source-php--flasher/php--flasher-blue.svg" alt="Source Code Badge"></a>
 17 |     <a href="https://github.com/php-flasher/php-flasher/releases"><img src="https://img.shields.io/github/tag/php-flasher/flasher.svg" alt="GitHub Release Badge"></a>
 18 |     <a href="https://github.com/php-flasher/flasher/blob/master/LICENSE"><img src="https://img.shields.io/badge/license-MIT-brightgreen.svg" alt="License Badge"></a>
 19 |     <a href="https://packagist.org/packages/php-flasher/flasher"><img src="https://img.shields.io/packagist/dt/php-flasher/flasher.svg" alt="Packagist Downloads Badge"></a>
 20 |     <a href="https://github.com/php-flasher/php-flasher"><img src="https://img.shields.io/github/stars/php-flasher/php-flasher.svg" alt="GitHub Stars Badge"></a>
 21 |     <a href="https://packagist.org/packages/php-flasher/flasher"><img src="https://img.shields.io/packagist/php-v/php-flasher/flasher.svg" alt="Supported PHP Version Badge"></a>
 22 | </p>
 23 | 
 24 | ## Table of Contents
 25 | 
 26 | - [About PHPFlasher Symfony Adapter](#about-phpflasher-symfony-adapter)
 27 | - [Features](#features)
 28 | - [Supported Versions](#supported-versions)
 29 | - [Installation](#installation)
 30 |     - [Core Package](#core-package)
 31 |     - [Adapters](#adapters)
 32 | - [Configuration](#configuration)
 33 |     - [Configuration File](#configuration-file)
 34 |     - [Configuration Options](#configuration-options)
 35 | - [Quick Start](#quick-start)
 36 | - [Usage Examples](#usage-examples)
 37 | - [Adapters Overview](#adapters-overview)
 38 | - [Official Documentation](#official-documentation)
 39 | - [Contributors and Sponsors](#contributors-and-sponsors)
 40 | - [Contact](#contact)
 41 | - [License](#license)
 42 | 
 43 | ## About PHPFlasher Symfony Adapter
 44 | 
 45 | **PHPFlasher Symfony Adapter** is an open-source package that seamlessly integrates PHPFlasher’s robust flash messaging capabilities into your **Symfony** applications. It streamlines the process of adding flash messages, offering an intuitive API to enhance user experience with minimal configuration.
 46 | 
 47 | With PHPFlasher Symfony Adapter, you can effortlessly display success, error, warning, and informational messages to your users, ensuring clear communication of application states and actions.
 48 | 
 49 | ## Features
 50 | 
 51 | - **Seamless Symfony Integration**: Designed specifically for Symfony, ensuring compatibility and ease of use.
 52 | - **Multiple Notification Libraries**: Supports various frontend libraries like Toastr, Noty, SweetAlert, and Notyf.
 53 | - **Flexible Configuration**: Customize the appearance and behavior of flash messages to fit your application's needs.
 54 | - **Intuitive API**: Simple methods to create and manage flash messages without boilerplate code.
 55 | - **Extensible**: Easily add or create new adapters for different frontend libraries.
 56 | 
 57 | ## Supported Versions
 58 | 
 59 | | PHPFlasher Symfony Adapter Version | PHP Version | Symfony Version |
 60 | |------------------------------------|-------------|-----------------|
 61 | | **v2.x**                           | ≥ 8.2       | ≥ 7.0           |
 62 | | **v1.x**                           | ≥ 5.3       | ≥ 2.0           |
 63 | 
 64 | > **Note:** Ensure your project meets the PHP and Symfony version requirements for the PHPFlasher Symfony Adapter version you intend to use. For older PHP or Symfony versions, refer to [PHPFlasher v1.x](https://github.com/php-flasher/flasher-symfony/tree/1.x).
 65 | 
 66 | ## Installation
 67 | 
 68 | ### Core Package
 69 | 
 70 | Install the PHPFlasher Symfony Adapter via Composer:
 71 | 
 72 | ```bash
 73 | composer require php-flasher/flasher-symfony
 74 | ```
 75 | 
 76 | After installation, set up the necessary assets:
 77 | 
 78 | ```shell
 79 | php bin/console flasher:install
 80 | ```
 81 | 
 82 | > **Note:** PHPFlasher automatically injects the necessary JavaScript and CSS assets into your Blade templates. No additional steps are required for asset injection.
 83 | 
 84 | ### Adapters
 85 | 
 86 | PHPFlasher provides various adapters for different notification libraries. Below is an overview of available adapters for Symfony:
 87 | 
 88 | - [flasher-toastr-symfony](https://github.com/php-flasher/flasher-toastr-symfony) - Symfony Adapter
 89 | - [flasher-noty-symfony](https://github.com/php-flasher/flasher-noty-symfony) - Symfony Adapter
 90 | - [flasher-notyf-symfony](https://github.com/php-flasher/flasher-notyf-symfony) - Symfony Adapter
 91 | - [flasher-sweetalert-symfony](https://github.com/php-flasher/flasher-sweetalert-symfony) - Symfony Adapter
 92 | 
 93 | For detailed installation and usage instructions for each adapter, refer to their respective `README.md`.
 94 | 
 95 | ## Configuration
 96 | 
 97 | After installing the PHPFlasher Symfony Adapter, you can configure it by publishing the configuration file or by modifying it directly.
 98 | 
 99 | ### Configuration File
100 | 
101 | If you need to customize the default settings, publish the configuration file using the following command:
102 | 
103 | ```bash
104 | php bin/console flasher:install --config
105 | ```
106 | 
107 | This will create a file at `config/packages/flasher.yaml` with the following content:
108 | 
109 | ```yaml
110 | flasher:
111 |     # Default notification library (e.g., 'flasher', 'toastr', 'noty', 'notyf', 'sweetalert')
112 |     default: flasher
113 | 
114 |     # Path to the main PHPFlasher JavaScript file
115 |     main_script: '/vendor/flasher/flasher.min.js'
116 | 
117 |     # List of CSS files to style your notifications
118 |     styles:
119 |         - '/vendor/flasher/flasher.min.css'
120 | 
121 |     # Set global options for all notifications (optional)
122 |     # options:
123 |     #     # Time in milliseconds before the notification disappears
124 |     #     timeout: 5000
125 |     #     # Where the notification appears on the screen
126 |     #     position: 'top-right'
127 | 
128 |     # Automatically inject JavaScript and CSS assets into your HTML pages
129 |     inject_assets: true
130 | 
131 |     # Enable message translation using Symfony's translation service
132 |     translate: true
133 | 
134 |     # URL patterns to exclude from asset injection and flash_bag conversion
135 |     excluded_paths:
136 |         - '/^\/_profiler/'
137 |         - '/^\/_fragment/'
138 | 
139 |     # Map Symfony flash message keys to notification types
140 |     flash_bag:
141 |         success: ['success']
142 |         error: ['error', 'danger']
143 |         warning: ['warning', 'alarm']
144 |         info: ['info', 'notice', 'alert']
145 | 
146 |     # Set criteria to filter which notifications are displayed (optional)
147 |     # filter:
148 |     #     # Maximum number of notifications to show at once
149 |     #     limit: 5
150 | 
151 |     # Define notification presets to simplify notification creation (optional)
152 |     # presets:
153 |     #     # Example preset:
154 |     #     entity_saved:
155 |     #         type: 'success'
156 |     #         title: 'Entity saved'
157 |     #         message: 'Entity saved successfully'
158 | ```
159 | 
160 | ### Configuration Options
161 | 
162 | | **Option**       | **Description**                                                                                                           |
163 | |------------------|---------------------------------------------------------------------------------------------------------------------------|
164 | | `default`        | **String**: The default notification library to use (e.g., `'flasher'`, `'toastr'`, `'noty'`, `'notyf'`, `'sweetalert'`). |
165 | | `main_script`    | **String**: Path to the main PHPFlasher JavaScript file.                                                                  |
166 | | `styles`         | **Array**: List of CSS files to style your notifications.                                                                 |
167 | | `options`        | **Array** (Optional): Global options for all notifications (e.g., `'timeout'`, `'position'`).                             |
168 | | `inject_assets`  | **Boolean**: Whether to automatically inject JavaScript and CSS assets into your HTML pages.                              |
169 | | `translate`      | **Boolean**: Enable message translation using Symfony’s translation service.                                              |
170 | | `excluded_paths` | **Array**: URL patterns to exclude from asset injection and flash_bag conversion.                                         |
171 | | `flash_bag`      | **Array**: Map Symfony flash message keys to notification types.                                                          |
172 | | `filter`         | **Array** (Optional): Criteria to filter which notifications are displayed (e.g., `'limit'`).                             |
173 | | `presets`        | **Array** (Optional): Define notification presets to simplify notification creation.                                      |
174 | 
175 | ## Quick Start
176 | 
177 | To display a notification message, you can either use the `flash()` helper function or obtain an instance of `flasher` from the service container. Then, before returning a view or redirecting, call the desired method (`success()`, `error()`, etc.) and pass in the message to be displayed.
178 | 
179 | ### Using the `flash()` Helper
180 | 
181 | ```php
182 | <?php
183 | 
184 | namespace App\Controller;
185 | 
186 | use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
187 | use Symfony\Component\HttpFoundation\RedirectResponse;
188 | 
189 | class BookController extends AbstractController
190 | {
191 |     public function saveBook(): RedirectResponse
192 |     {
193 |         // Your logic here
194 | 
195 |         flash('Your changes have been saved!');
196 | 
197 |         return $this->redirectToRoute('book_list');
198 |     }
199 | }
200 | ```
201 | 
202 | ### Using the `flasher` Service
203 | 
204 | ```php
205 | <?php
206 | 
207 | namespace App\Controller;
208 | 
209 | use Flasher\Prime\FlasherInterface;
210 | use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
211 | use Symfony\Component\HttpFoundation\RedirectResponse;
212 | 
213 | class AnotherController extends AbstractController
214 | {
215 |     private FlasherInterface $flasher;
216 | 
217 |     public function __construct(FlasherInterface $flasher)
218 |     {
219 |         $this->flasher = $flasher;
220 |     }
221 | 
222 |     public function register(): RedirectResponse
223 |     {
224 |         // Your logic here
225 |         
226 |         $this->flasher->success('Your changes have been saved!');
227 | 
228 |         // ... redirect or render the view
229 |         return $this->redirectToRoute('home');
230 |     }
231 | 
232 |     public function update(): RedirectResponse
233 |     {
234 |         // Your logic here
235 | 
236 |         $this->flasher->error('An error occurred while updating.');
237 | 
238 |         return $this->redirectToRoute('update_page');
239 |     }
240 | }
241 | ```
242 | 
243 | ## Usage Examples
244 | 
245 | ### Success Message
246 | 
247 | ```php
248 | flash()->success('Operation completed successfully!');
249 | ```
250 | 
251 | ### Error Message
252 | 
253 | ```php
254 | flash()->error('An error occurred.');
255 | ```
256 | 
257 | ### Info Message
258 | 
259 | ```php
260 | flash()->info('This is an informational message.');
261 | ```
262 | 
263 | ### Warning Message
264 | 
265 | ```php
266 | flash()->warning('This is a warning message.');
267 | ```
268 | 
269 | ### Passing Options
270 | 
271 | ```php
272 | flash()->success('Custom message with options.', ['timeout' => 3000, 'position' => 'bottom-left']);
273 | ```
274 | 
275 | ### Using presets
276 | 
277 | Define a preset in your `config/packages/flasher.yaml`:
278 | 
279 | ```yaml
280 | flasher:
281 |     # ... other configurations
282 | 
283 |     presets:
284 |         entity_saved:
285 |             type: 'success'
286 |             title: 'Entity Saved'
287 |             message: 'The entity has been saved successfully.'
288 |         entity_deleted:
289 |             type: 'warning'
290 |             title: 'Entity Deleted'
291 |             message: 'The entity has been deleted.'
292 | ```
293 | 
294 | Use the preset in your controller:
295 | 
296 | ```php
297 | <?php
298 | 
299 | namespace App\Controller;
300 | 
301 | use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
302 | use Symfony\Component\HttpFoundation\RedirectResponse;
303 | 
304 | class BookController extends AbstractController
305 | {
306 |     public function save(): RedirectResponse
307 |     {
308 |         // Your saving logic
309 | 
310 |         flash()->preset('entity_saved');
311 | 
312 |         return $this->redirectToRoute('books.index');
313 |     }
314 | 
315 |     public function delete(): RedirectResponse
316 |     {
317 |         // Your deletion logic
318 | 
319 |         flash()->preset('entity_deleted');
320 | 
321 |         return $this->redirectToRoute('books.index');
322 |     }
323 | }
324 | ```
325 | 
326 | ## Adapters Overview
327 | 
328 | PHPFlasher supports various adapters to integrate seamlessly with different frontend libraries. Below is an overview of available adapters for Symfony:
329 | 
330 | | Adapter Repository                                                                      | Description                    |
331 | |-----------------------------------------------------------------------------------------|--------------------------------|
332 | | [flasher-symfony](https://github.com/php-flasher/flasher-symfony)                       | Symfony framework adapter      |
333 | | [flasher-toastr-symfony](https://github.com/php-flasher/flasher-toastr-symfony)         | Toastr adapter for Symfony     |
334 | | [flasher-noty-symfony](https://github.com/php-flasher/flasher-noty-symfony)             | Noty adapter for Symfony       |
335 | | [flasher-notyf-symfony](https://github.com/php-flasher/flasher-notyf-symfony)           | Notyf adapter for Symfony      |
336 | | [flasher-sweetalert-symfony](https://github.com/php-flasher/flasher-sweetalert-symfony) | SweetAlert adapter for Symfony |
337 | 
338 | > **Note:** Each adapter has its own repository. For detailed installation and usage instructions, please refer to the [Official Documentation](https://php-flasher.io).
339 | 
340 | ## Official Documentation
341 | 
342 | Comprehensive documentation for PHPFlasher is available at [https://php-flasher.io](https://php-flasher.io). Here you will find detailed guides, API references, and advanced usage examples to help you get the most out of PHPFlasher.
343 | 
344 | ## Contributors and sponsors
345 | 
346 | Join our team of contributors and make a lasting impact on our project!
347 | 
348 | We are always looking for passionate individuals who want to contribute their skills and ideas.
349 | Whether you're a developer, designer, or simply have a great idea, we welcome your participation and collaboration.
350 | 
351 | Shining stars of our community:
352 | 
353 | <!-- ALL-CONTRIBUTORS-LIST:START -->
354 | <!-- prettier-ignore-start -->
355 | <!-- markdownlint-disable -->
356 | <table>
357 |   <tbody>
358 |     <tr>
359 |       <td align="center" valign="top" width="14.28%"><a href="https://www.linkedin.com/in/younes--ennaji/"><img src="https://avatars.githubusercontent.com/u/10859693?v=4?s=100" width="100px;" alt="Younes ENNAJI"/><br /><sub><b>Younes ENNAJI</b></sub></a><br /><a href="https://github.com/php-flasher/php-flasher/commits?author=yoeunes" title="Code">💻</a> <a href="https://github.com/php-flasher/php-flasher/commits?author=yoeunes" title="Documentation">📖</a> <a href="#maintenance-yoeunes" title="Maintenance">🚧</a></td>
360 |       <td align="center" valign="top" width="14.28%"><a href="https://github.com/salmayno"><img src="https://avatars.githubusercontent.com/u/27933199?v=4?s=100" width="100px;" alt="Salma Mourad"/><br /><sub><b>Salma Mourad</b></sub></a><br /><a href="#financial-salmayno" title="Financial">💵</a></td>
361 |       <td align="center" valign="top" width="14.28%"><a href="https://www.youtube.com/rstacode"><img src="https://avatars.githubusercontent.com/u/35005761?v=4?s=100" width="100px;" alt="Nashwan Abdullah"/><br /><sub><b>Nashwan Abdullah</b></sub></a><br /><a href="#financial-codenashwan" title="Financial">💵</a></td>
362 |       <td align="center" valign="top" width="14.28%"><a href="https://darvis.nl/"><img src="https://avatars.githubusercontent.com/u/7394837?v=4?s=100" width="100px;" alt="Arvid de Jong"/><br /><sub><b>Arvid de Jong</b></sub></a><br /><a href="#financial-darviscommerce" title="Financial">💵</a></td>
363 |       <td align="center" valign="top" width="14.28%"><a href="https://ashallendesign.co.uk/"><img src="https://avatars.githubusercontent.com/u/39652331?v=4?s=100" width="100px;" alt="Ash Allen"/><br /><sub><b>Ash Allen</b></sub></a><br /><a href="#design-ash-jc-allen" title="Design">🎨</a></td>
364 |       <td align="center" valign="top" width="14.28%"><a href="https://about.me/murrant"><img src="https://avatars.githubusercontent.com/u/39462?v=4?s=100" width="100px;" alt="Tony Murray"/><br /><sub><b>Tony Murray</b></sub></a><br /><a href="https://github.com/php-flasher/php-flasher/commits?author=murrant" title="Code">💻</a></td>
365 |       <td align="center" valign="top" width="14.28%"><a href="https://github.com/n3wborn"><img src="https://avatars.githubusercontent.com/u/10246722?v=4?s=100" width="100px;" alt="Stéphane P"/><br /><sub><b>Stéphane P</b></sub></a><br /><a href="https://github.com/php-flasher/php-flasher/commits?author=n3wborn" title="Documentation">📖</a></td>
366 |     </tr>
367 |     <tr>
368 |       <td align="center" valign="top" width="14.28%"><a href="https://www.instagram.com/lucas.maciel_z"><img src="https://avatars.githubusercontent.com/u/80225404?v=4?s=100" width="100px;" alt="Lucas Maciel"/><br /><sub><b>Lucas Maciel</b></sub></a><br /><a href="#design-LucasStorm" title="Design">🎨</a></td>
369 |       <td align="center" valign="top" width="14.28%"><a href="https://github.com/AhmedGamal"><img src="https://avatars.githubusercontent.com/u/11786167?v=4?s=100" width="100px;" alt="Ahmed Gamal"/><br /><sub><b>Ahmed Gamal</b></sub></a><br /><a href="https://github.com/php-flasher/php-flasher/commits?author=AhmedGamal" title="Code">💻</a> <a href="https://github.com/php-flasher/php-flasher/commits?author=AhmedGamal" title="Documentation">📖</a></td>
370 |     </tr>
371 |   </tbody>
372 | </table>
373 | 
374 | <!-- markdownlint-restore -->
375 | <!-- prettier-ignore-end -->
376 | 
377 | <!-- ALL-CONTRIBUTORS-LIST:END -->
378 | 
379 | ## Contact
380 | 
381 | PHPFlasher is being actively developed by <a href="https://github.com/yoeunes">yoeunes</a>.
382 | You can reach out with questions, bug reports, or feature requests on any of the following:
383 | 
384 | - [Github Issues](https://github.com/php-flasher/php-flasher/issues)
385 | - [Github](https://github.com/yoeunes)
386 | - [Twitter](https://twitter.com/yoeunes)
387 | - [Linkedin](https://www.linkedin.com/in/younes--ennaji/)
388 | - [Email me directly](mailto:younes.ennaji.pro@gmail.com)
389 | 
390 | ## License
391 | 
392 | PHPFlasher is open-sourced software licensed under the [MIT license](https://opensource.org/licenses/MIT).
393 | 
394 | <p align="center"> <b>Made with ❤️ by <a href="https://www.linkedin.com/in/younes--ennaji/">Younes ENNAJI</a> </b> </p>
395 | 


--------------------------------------------------------------------------------
/Resources/config/config.yaml:
--------------------------------------------------------------------------------
 1 | flasher:
 2 |     # Default notification library (e.g., 'flasher', 'toastr', 'noty', 'notyf', 'sweetalert')
 3 |     default: flasher
 4 | 
 5 |     # Path to the main PHPFlasher JavaScript file
 6 |     main_script: '/vendor/flasher/flasher.min.js'
 7 | 
 8 |     # List of CSS files to style your notifications
 9 |     styles:
10 |         - '/vendor/flasher/flasher.min.css'
11 | 
12 |     # Set global options for all notifications (optional)
13 |     # options:
14 |     #     # Time in milliseconds before the notification disappears
15 |     #     timeout: 5000
16 |     #     # Where the notification appears on the screen
17 |     #     position: 'top-right'
18 | 
19 |     # Automatically inject JavaScript and CSS assets into your HTML pages
20 |     inject_assets: true
21 | 
22 |     # Enable message translation using Symfony's translation service
23 |     translate: true
24 | 
25 |     # URL patterns to exclude from asset injection and flash_bag conversion
26 |     excluded_paths:
27 |         - '/^\/_profiler/'
28 |         - '/^\/_fragment/'
29 | 
30 |     # Map Symfony flash message keys to notification types
31 |     flash_bag:
32 |         success: ['success']
33 |         error: ['error', 'danger']
34 |         warning: ['warning', 'alarm']
35 |         info: ['info', 'notice', 'alert']
36 | 
37 |     # Set criteria to filter which notifications are displayed (optional)
38 |     # filter:
39 |     #     # Maximum number of notifications to show at once
40 |     #     limit: 5
41 | 
42 |     # Define notification presets to simplify notification creation (optional)
43 |     # presets:
44 |     #     # Example preset:
45 |     #     entity_saved:
46 |     #         type: 'success'
47 |     #         title: 'Entity saved'
48 |     #         message: 'Entity saved successfully'
49 | 


--------------------------------------------------------------------------------
/Resources/config/services.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | use Flasher\Prime\Asset\AssetManager;
  6 | use Flasher\Prime\EventDispatcher\EventDispatcher;
  7 | use Flasher\Prime\EventDispatcher\EventListener\ApplyPresetListener;
  8 | use Flasher\Prime\EventDispatcher\EventListener\NotificationLoggerListener;
  9 | use Flasher\Prime\EventDispatcher\EventListener\TranslationListener;
 10 | use Flasher\Prime\Factory\NotificationFactory;
 11 | use Flasher\Prime\Flasher;
 12 | use Flasher\Prime\FlasherInterface;
 13 | use Flasher\Prime\Http\Csp\ContentSecurityPolicyHandler;
 14 | use Flasher\Prime\Http\Csp\NonceGenerator;
 15 | use Flasher\Prime\Http\RequestExtension;
 16 | use Flasher\Prime\Http\ResponseExtension;
 17 | use Flasher\Prime\Response\Resource\ResourceManager;
 18 | use Flasher\Prime\Response\ResponseManager;
 19 | use Flasher\Prime\Storage\Filter\FilterFactory;
 20 | use Flasher\Prime\Storage\Storage;
 21 | use Flasher\Prime\Storage\StorageManager;
 22 | use Flasher\Symfony\Command\InstallCommand;
 23 | use Flasher\Symfony\Component\FlasherComponent;
 24 | use Flasher\Symfony\EventListener\FlasherListener;
 25 | use Flasher\Symfony\EventListener\SessionListener;
 26 | use Flasher\Symfony\Factory\NotificationFactoryLocator;
 27 | use Flasher\Symfony\Profiler\FlasherDataCollector;
 28 | use Flasher\Symfony\Storage\SessionBag;
 29 | use Flasher\Symfony\Template\TwigTemplateEngine;
 30 | use Flasher\Symfony\Translation\Translator;
 31 | use Flasher\Symfony\Twig\FlasherTwigExtension;
 32 | use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
 33 | 
 34 | use function Symfony\Component\DependencyInjection\Loader\Configurator\inline_service;
 35 | use function Symfony\Component\DependencyInjection\Loader\Configurator\param;
 36 | use function Symfony\Component\DependencyInjection\Loader\Configurator\service;
 37 | use function Symfony\Component\DependencyInjection\Loader\Configurator\tagged_locator;
 38 | 
 39 | return static function (ContainerConfigurator $container): void {
 40 |     $container->services()
 41 |         ->set('flasher', Flasher::class)
 42 |             ->public()
 43 |             ->args([
 44 |                 param('flasher.default'),
 45 |                 inline_service(NotificationFactoryLocator::class)
 46 |                     ->args([tagged_locator('flasher.factory', indexAttribute: 'alias')]),
 47 |                 service('flasher.response_manager'),
 48 |                 service('flasher.storage_manager'),
 49 |             ])
 50 |             ->alias(FlasherInterface::class, 'flasher')
 51 | 
 52 |         ->set('flasher.flasher_listener', FlasherListener::class)
 53 |             ->args([
 54 |                 inline_service(ResponseExtension::class)
 55 |                     ->args([
 56 |                         service('flasher'),
 57 |                         service('flasher.csp_handler'),
 58 |                         param('flasher.excluded_paths'),
 59 |                     ]),
 60 |             ])
 61 |             ->tag('kernel.event_subscriber')
 62 | 
 63 |         ->set('flasher.twig_extension', FlasherTwigExtension::class)
 64 |             ->args([service('flasher')])
 65 |             ->tag('twig.extension')
 66 | 
 67 |         ->set('flasher.session_listener', SessionListener::class)
 68 |             ->args([
 69 |                 inline_service(RequestExtension::class)
 70 |                     ->args([
 71 |                         service('flasher'),
 72 |                         param('flasher.flash_bag'),
 73 |                     ]),
 74 |             ])
 75 |             ->tag('kernel.event_subscriber')
 76 | 
 77 |         ->set('flasher.notification_logger_listener', NotificationLoggerListener::class)
 78 |             ->tag('flasher.event_listener')
 79 |             ->tag('kernel.reset', ['method' => 'reset'])
 80 | 
 81 |         ->set('flasher.translation_listener', TranslationListener::class)
 82 |             ->args([service('flasher.translator')->nullOnInvalid()])
 83 |             ->tag('flasher.event_listener')
 84 | 
 85 |         ->set('flasher.preset_listener', ApplyPresetListener::class)
 86 |             ->args([param('flasher.presets')])
 87 |             ->tag('flasher.event_listener')
 88 | 
 89 |         ->set('flasher.install_command', InstallCommand::class)
 90 |             ->args([service('flasher.asset_manager')])
 91 |             ->tag('console.command')
 92 | 
 93 |         ->set('flasher.flasher_component', FlasherComponent::class)
 94 |             ->tag('twig.component', [
 95 |                 'key' => 'flasher',
 96 |                 'template' => '@FlasherSymfony/components/flasher.html.twig',
 97 |                 'attributesVar' => 'attributes',
 98 |             ])
 99 | 
100 |         ->set('flasher.notification_factory', NotificationFactory::class)
101 |             ->abstract()
102 |             ->args([service('flasher.storage_manager')])
103 | 
104 |         ->set('flasher.storage', Storage::class)
105 |             ->args([service('flasher.storage_bag')])
106 | 
107 |         ->set('flasher.storage_bag', SessionBag::class)
108 |             ->args([service('request_stack')])
109 | 
110 |         ->set('flasher.event_dispatcher', EventDispatcher::class)
111 | 
112 |         ->set('flasher.filter_factory', FilterFactory::class)
113 | 
114 |         ->set('flasher.storage_manager', StorageManager::class)
115 |             ->args([
116 |                 service('flasher.storage'),
117 |                 service('flasher.event_dispatcher'),
118 |                 service('flasher.filter_factory'),
119 |                 param('flasher.filter'),
120 |             ])
121 | 
122 |         ->set('flasher.template_engine', TwigTemplateEngine::class)
123 |             ->args([service('twig')->nullOnInvalid()])
124 | 
125 |         ->set('flasher.resource_manager', ResourceManager::class)
126 |             ->args([
127 |                 service('flasher.template_engine'),
128 |                 service('flasher.asset_manager'),
129 |                 param('flasher.main_script'),
130 |                 param('flasher.plugins'),
131 |             ])
132 | 
133 |         ->set('flasher.response_manager', ResponseManager::class)
134 |             ->args([
135 |                 service('flasher.resource_manager'),
136 |                 service('flasher.storage_manager'),
137 |                 service('flasher.event_dispatcher'),
138 |             ])
139 | 
140 |         ->set('flasher.translator', Translator::class)
141 |             ->args([service('translator')->nullOnInvalid()])
142 | 
143 |         ->set('flasher.csp_handler', ContentSecurityPolicyHandler::class)
144 |             ->args([inline_service(NonceGenerator::class)])
145 | 
146 |         ->set('flasher.asset_manager', AssetManager::class)
147 |             ->args([
148 |                 param('flasher.public_dir'),
149 |                 param('flasher.json_manifest_path'),
150 |             ])
151 | 
152 |         ->set('flasher.data_collector', FlasherDataCollector::class)
153 |             ->args([
154 |                 service('flasher.notification_logger_listener'),
155 |                 param('flasher'),
156 |             ])
157 |             ->tag('data_collector', ['id' => 'flasher', 'template' => '@FlasherSymfony/profiler/flasher.html.twig', 'priority' => 0])
158 |     ;
159 | };
160 | 


--------------------------------------------------------------------------------
/Resources/translations/flasher.ar.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | declare(strict_types=1);
4 | 
5 | return Flasher\Prime\Translation\Messages::get('ar');
6 | 


--------------------------------------------------------------------------------
/Resources/translations/flasher.de.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | declare(strict_types=1);
4 | 
5 | return Flasher\Prime\Translation\Messages::get('de');
6 | 


--------------------------------------------------------------------------------
/Resources/translations/flasher.en.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | declare(strict_types=1);
4 | 
5 | return Flasher\Prime\Translation\Messages::get('en');
6 | 


--------------------------------------------------------------------------------
/Resources/translations/flasher.es.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | declare(strict_types=1);
4 | 
5 | return Flasher\Prime\Translation\Messages::get('es');
6 | 


--------------------------------------------------------------------------------
/Resources/translations/flasher.fr.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | declare(strict_types=1);
4 | 
5 | return Flasher\Prime\Translation\Messages::get('fr');
6 | 


--------------------------------------------------------------------------------
/Resources/translations/flasher.pt.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | declare(strict_types=1);
4 | 
5 | return Flasher\Prime\Translation\Messages::get('pt');
6 | 


--------------------------------------------------------------------------------
/Resources/translations/flasher.ru.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | declare(strict_types=1);
4 | 
5 | return Flasher\Prime\Translation\Messages::get('ru');
6 | 


--------------------------------------------------------------------------------
/Resources/translations/flasher.zh.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | declare(strict_types=1);
4 | 
5 | return Flasher\Prime\Translation\Messages::get('zh');
6 | 


--------------------------------------------------------------------------------
/Resources/views/bootstrap.html.twig:
--------------------------------------------------------------------------------
 1 | {% if 'success' == envelope.type %}
 2 |     {% set title = 'Success' %}
 3 |     {% set alert_class = 'alert-success' %}
 4 |     {% set progress_bg_color = '#155724' %}
 5 | {% elseif 'error' == envelope.type %}
 6 |     {% set title = 'Error' %}
 7 |     {% set alert_class = 'alert-danger' %}
 8 |     {% set progress_bg_color = '#721c24' %}
 9 | {% elseif 'warning' == envelope.type %}
10 |     {% set title = 'Warning' %}
11 |     {% set alert_class = 'alert-warning' %}
12 |     {% set progress_bg_color = '#856404' %}
13 | {% else %}
14 |     {% set title = 'Info' %}
15 |     {% set alert_class = 'alert-info' %}
16 |     {% set progress_bg_color = '#0c5460' %}
17 | {% endif %}
18 | 
19 | <div style="margin-top: 0.5rem;cursor: pointer;">
20 |     <div class="alert {{ alert_class }} alert-dismissible fade in show" role="alert" style="border-top-left-radius: 0;border-bottom-left-radius: 0;border: unset;border-left: 6px solid {{ progress_bg_color }}">
21 |         {#        <strong>{{ title | trans }} !</strong> #}
22 |         {{ envelope.message }}
23 |         <button type="button" class="close" data-dismiss="alert" aria-label="Close" onclick="this.parentElement.remove()">
24 |             <span aria-hidden="true">&times;</span>
25 |         </button>
26 |     </div>
27 |     <div class="d-flex" style="height: .125rem;margin-top: -1rem;">
28 |         <span class="flasher-progress" style="background-color: {{ progress_bg_color }}"></span>
29 |     </div>
30 | </div>
31 | 


--------------------------------------------------------------------------------
/Resources/views/components/flasher.html.twig:
--------------------------------------------------------------------------------
1 | <div {{ attributes }}>
2 |     {{ flasher_render() }}
3 | </div>
4 | 


--------------------------------------------------------------------------------
/Resources/views/profiler/_notifications_table.html.twig:
--------------------------------------------------------------------------------
 1 | <table class="notifications-table">
 2 |     <thead>
 3 |     <tr>
 4 |         <th>#</th>
 5 |         <th>Plugin</th>
 6 |         <th>Type</th>
 7 |         <th>Title</th>
 8 |         <th>Message</th>
 9 |         <th>Options</th>
10 |     </tr>
11 |     </thead>
12 |     <tbody>
13 |         {% for envelope in envelopes %}
14 |             <tr>
15 |                 <td>{{ loop.index }}</td>
16 |                 <td>{{ envelope.metadata.plugin }}</td>
17 |                 <td class="notification-type-{{ envelope.type|lower }}">{{ envelope.type }}</td>
18 |                 <td>{{ envelope.title }}</td>
19 |                 <td>{{ envelope.message }}</td>
20 |                 <td>
21 |                     {% if envelope.options is not empty %}
22 |                         {{ profiler_dump(envelope.options) }}
23 |                     {% else %}
24 |                         <em>No Options</em>
25 |                     {% endif %}
26 |                 </td>
27 |             </tr>
28 |         {% endfor %}
29 |     </tbody>
30 | </table>
31 | 


--------------------------------------------------------------------------------
/Resources/views/profiler/flasher.html.twig:
--------------------------------------------------------------------------------
  1 | {% extends '@WebProfiler/Profiler/layout.html.twig' %}
  2 | 
  3 | {% macro logo() %}
  4 |     <strong style="line-height: 1; display: inline-block; font-size: 0;">
  5 |         <span style="
  6 |             color: #FFFFFF;
  7 |             background-color: #312E81;
  8 |             padding: 2px 0 2px 4px;
  9 |             display: inline-block;
 10 |             font-size: 16px;
 11 |         ">PHP</span><span style="
 12 |             color: #FFFFFF;
 13 |             background-color: #6366F1;
 14 |             padding: 2px 4px 2px 0;
 15 |             display: inline-block;
 16 |             font-size: 16px;
 17 |         ">Flasher</span>
 18 |     </strong>
 19 | {% endmacro %}
 20 | 
 21 | {% block toolbar %}
 22 |     {% import _self as macros %}
 23 | 
 24 |     {% set displayedEnvelopes = collector.displayedEnvelopes %}
 25 |     {% set dispatchedEnvelopes = collector.dispatchedEnvelopes %}
 26 | 
 27 |     {% set totalDispatched = dispatchedEnvelopes|length %}
 28 |     {% set totalDisplayed = displayedEnvelopes|length %}
 29 | 
 30 |     {% if totalDisplayed > 0 %}
 31 |         {# Initialize type counts #}
 32 |         {% set typeCounts = {} %}
 33 |         {% for envelope in displayedEnvelopes %}
 34 |             {% set type = envelope.type|default('info')|lower %}
 35 |             {% set typeCounts = typeCounts | merge({ (type): (typeCounts[type]|default(0) + 1) }) %}
 36 |         {% endfor %}
 37 | 
 38 |         {% set icon %}
 39 |             {{ macros.logo() }}
 40 | 
 41 |             {{ source('@FlasherSymfony/profiler/flasher.svg') }}
 42 |             <span class="sf-toolbar-value">
 43 |                 {% if totalDisplayed == totalDispatched %}
 44 |                     {{ totalDisplayed }}
 45 |                 {% else %}
 46 |                     {{ totalDisplayed }}/{{ totalDispatched }}
 47 |                 {% endif %}
 48 |             </span>
 49 |         {% endset %}
 50 | 
 51 |         {% set text %}
 52 |             <div class="sf-toolbar-info-piece">
 53 |                 <b>Notifications Displayed</b>
 54 |                 <span class="sf-toolbar-status">{{ totalDisplayed }}</span>
 55 |             </div>
 56 | 
 57 |             {% if totalDispatched != totalDisplayed %}
 58 |                 <div class="sf-toolbar-info-piece">
 59 |                     <b>Notifications Dispatched:</b>
 60 |                     <span class="sf-toolbar-status">{{ totalDispatched }}</span>
 61 |                 </div>
 62 |             {% endif %}
 63 | 
 64 |             {% if totalDisplayed > totalDispatched %}
 65 |                 <div class="sf-toolbar-info-piece">
 66 |                     <span>Note: Some notifications are from previous requests.</span>
 67 |                 </div>
 68 |             {% endif %}
 69 | 
 70 |             {% for type, count in typeCounts %}
 71 |                 <div class="sf-toolbar-info-piece">
 72 |                     <b>{{ type|capitalize }}</b>
 73 |                     <span class="sf-toolbar-status">{{ count }}</span>
 74 |                 </div>
 75 |             {% endfor %}
 76 |         {% endset %}
 77 | 
 78 |         {{ include('@WebProfiler/Profiler/toolbar_item.html.twig', { link: profiler_url }) }}
 79 |     {% endif %}
 80 | {% endblock %}
 81 | 
 82 | {% block menu %}
 83 |     {% import _self as macros %}
 84 | 
 85 |     {% set totalDisplayed = collector.displayedEnvelopes|length %}
 86 |     {% set totalDispatched = collector.dispatchedEnvelopes|length %}
 87 | 
 88 |     <span class="label{% if totalDisplayed == 0 %} disabled{% endif %}">
 89 |         <span class="icon">{{ source('@FlasherSymfony/profiler/flasher.svg') }}</span>
 90 |         {{ macros.logo() }}
 91 |         {% if totalDisplayed > 0 %}
 92 |             <span class="count">
 93 |                 {% if totalDisplayed == totalDispatched %}
 94 |                     <span>{{ totalDisplayed }}</span>
 95 |                 {% else %}
 96 |                     <span>{{ totalDisplayed }}/{{ totalDispatched }}</span>
 97 |                 {% endif %}
 98 |             </span>
 99 |         {% endif %}
100 |     </span>
101 | {% endblock %}
102 | 
103 | {% block panel %}
104 |     {% set displayedEnvelopes = collector.displayedEnvelopes %}
105 |     {% set dispatchedEnvelopes = collector.dispatchedEnvelopes %}
106 |     {% set totalNotifications = dispatchedEnvelopes|length %}
107 |     {% set displayedNotifications = displayedEnvelopes|length %}
108 |     {% set config = collector.config %}
109 |     {% set versions = collector.versions %}
110 | 
111 |     <h2>PHPFlasher Notifications</h2>
112 | 
113 |     {% if totalNotifications == 0 %}
114 |         <div class="empty">
115 |             <p>No notifications have been dispatched.</p>
116 |         </div>
117 |     {% else %}
118 |         <div class="sf-tabs">
119 |             <div class="tab">
120 |                 <h3 class="tab-title">Notifications <span class="badge">{{ displayedNotifications }}/{{ totalNotifications }}</span></h3>
121 |                 <div class="tab-content">
122 |                     {% if displayedNotifications > totalNotifications %}
123 |                         <div class="sf-callout">
124 |                             <p>The number of displayed notifications is greater than the number of dispatched notifications. This may happen if notifications are stored in the session from previous requests.</p>
125 |                         </div>
126 |                     {% endif %}
127 | 
128 |                     <h4>Displayed Notifications</h4>
129 |                     {{ include('@FlasherSymfony/profiler/_notifications_table.html.twig', { 'envelopes': displayedEnvelopes }) }}
130 | 
131 |                     {% if totalNotifications > displayedNotifications %}
132 |                         <h4>Remaining Notifications</h4>
133 |                         {% set remainingNotifications = dispatchedEnvelopes|slice(displayedNotifications) %}
134 |                         {{ include('@FlasherSymfony/profiler/_notifications_table.html.twig', { 'envelopes': remainingNotifications }) }}
135 |                     {% endif %}
136 |                 </div>
137 |             </div>
138 | 
139 |             <div class="tab">
140 |                 <h3 class="tab-title">Debug</h3>
141 |                 <div class="tab-content">
142 |                     <h4>Version Information</h4>
143 |                     <ul>
144 |                         <li><strong>PHPFlasher Version:</strong> {{ versions.php_flasher }}</li>
145 |                         <li><strong>PHP Version:</strong> {{ versions.php }}</li>
146 |                         <li><strong>Symfony Version:</strong> {{ versions.symfony }}</li>
147 |                     </ul>
148 | 
149 |                     <h4>Configuration</h4>
150 |                     {{ profiler_dump(config, maxDepth=10) }}
151 |                 </div>
152 |             </div>
153 |         </div>
154 |     {% endif %}
155 | {% endblock %}
156 | 
157 | {% block head %}
158 |     {{ parent() }}
159 |     <style>
160 |         .sf-tabs .tab-content {
161 |             background-color: transparent;
162 |         }
163 |         .sf-tabs .tab-title {
164 |             cursor: pointer;
165 |         }
166 |         .notification-type-success { color: #10b981; }
167 |         .notification-type-error { color: #ef4444; }
168 |         .notification-type-info { color: #3b82f6; }
169 |         .notification-type-warning { color: #f59e0b; }
170 |         table.notifications-table {
171 |             width: 100%;
172 |             border-collapse: collapse;
173 |             margin-bottom: 20px;
174 |         }
175 |         table.notifications-table th, table.notifications-table td {
176 |             padding: 8px;
177 |             vertical-align: top;
178 |         }
179 |         .metadata {
180 |             font-size: 0.9em;
181 |             color: #555;
182 |         }
183 |     </style>
184 | {% endblock %}
185 | 


--------------------------------------------------------------------------------
/Resources/views/profiler/flasher.svg:
--------------------------------------------------------------------------------
1 | <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor"
2 |      stroke-width="2" stroke-linecap="round" stroke-linejoin="round"
3 |      class="icon icon-tabler icons-tabler-outline icon-tabler-bell-ringing-2">
4 |     <path stroke="none" d="M0 0h24v24H0z" fill="none"/>
5 |     <path
6 |         d="M19.364 4.636a2 2 0 0 1 0 2.828a7 7 0 0 1 -1.414 7.072l-2.122 2.12a4 4 0 0 0 -.707 3.536l-11.313 -11.312a4 4 0 0 0 3.535 -.707l2.121 -2.123a7 7 0 0 1 7.072 -1.414a2 2 0 0 1 2.828 0z"/>
7 |     <path d="M7.343 12.414l-.707 .707a3 3 0 0 0 4.243 4.243l.707 -.707"/>
8 | </svg>
9 | 


--------------------------------------------------------------------------------
/Resources/views/tailwindcss.html.twig:
--------------------------------------------------------------------------------
 1 | {% if 'success' == envelope.type %}
 2 |     {% set title = 'Success' %}
 3 |     {% set text_color = 'text-green-600' %}
 4 |     {% set ring_color = 'ring-green-300' %}
 5 |     {% set background_color = 'bg-green-600' %}
 6 |     {% set progress_background_color = 'bg-green-100' %}
 7 |     {% set border_color = 'border-green-600' %}
 8 |     {% set icon = '<svg fill="none" viewBox="0 0 24 24" stroke="currentColor" class="check w-7 h-7"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/></svg>' %}
 9 | {% elseif 'error' == envelope.type %}
10 |     {% set title = 'Error' %}
11 |     {% set text_color = 'text-red-600' %}
12 |     {% set ring_color = 'ring-red-300' %}
13 |     {% set background_color = 'bg-red-600' %}
14 |     {% set progress_background_color = 'bg-red-100' %}
15 |     {% set border_color = 'border-red-600' %}
16 |     {% set icon = '<svg fill="none" viewBox="0 0 24 24" stroke="currentColor" class="x w-7 h-7"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"/></svg>' %}
17 | {% elseif 'warning' == envelope.type %}
18 |     {% set title = 'Warning' %}
19 |     {% set text_color = 'text-yellow-600' %}
20 |     {% set ring_color = 'ring-yellow-300' %}
21 |     {% set background_color = 'bg-yellow-600' %}
22 |     {% set progress_background_color = 'bg-yellow-100' %}
23 |     {% set border_color = 'border-yellow-600' %}
24 |     {% set icon = '<svg fill="none" viewBox="0 0 24 24" stroke="currentColor" class="exclamation w-7 h-7"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"/></svg>' %}
25 | {% else %}
26 |     {% set title = 'Info' %}
27 |     {% set text_color = 'text-blue-600' %}
28 |     {% set ring_color = 'ring-blue-300' %}
29 |     {% set background_color = 'bg-blue-600' %}
30 |     {% set progress_background_color = 'bg-blue-100' %}
31 |     {% set border_color = 'border-blue-600' %}
32 |     {% set icon = '<svg class="w-8 h-8" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" /></svg>' %}
33 | {% endif %}
34 | 
35 | <div class="bg-white shadow-inner border-l-4 mt-2 cursor-pointer {{ border_color }}">
36 |     <div class="flex items-center px-2 py-3 rounded-lg shadow-lg overflow-hidden">
37 |         <div class="inline-flex items-center {{ background_color }} p-1 text-white text-sm rounded-full flex-shrink-0">
38 |             {{ icon | raw }}
39 |         </div>
40 |         <div class="ml-4 w-0 flex-1">
41 |             <p class="text-base leading-5 font-medium capitalize {{ text_color }}">
42 |                 {{ title | trans }}
43 |             </p>
44 |             <p class="mt-1 text-sm leading-5 text-gray-500">
45 |                 {{ envelope.message }}
46 |             </p>
47 |         </div>
48 |     </div>
49 |     <div class="h-0.5 flex {{ progress_background_color }}">
50 |         <span class="flasher-progress {{ background_color }}"></span>
51 |     </div>
52 | </div>
53 | 


--------------------------------------------------------------------------------
/Resources/views/tailwindcss_bg.html.twig:
--------------------------------------------------------------------------------
 1 | {% if 'success' == envelope.type %}
 2 |     {% set title = 'Success' %}
 3 |     {% set text_color = 'text-green-700' %}
 4 |     {% set background_color = 'bg-green-50' %}
 5 |     {% set progress_background_color = 'bg-green-200' %}
 6 |     {% set border_color = 'border-green-600' %}
 7 |     {% set icon = '<svg fill="none" viewBox="0 0 24 24" stroke="currentColor" class="check w-8 h-8"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/></svg>' %}
 8 | {% elseif 'error' == envelope.type %}
 9 |     {% set title = 'Error' %}
10 |     {% set text_color = 'text-red-700' %}
11 |     {% set background_color = 'bg-red-50' %}
12 |     {% set progress_background_color = 'bg-red-200' %}
13 |     {% set border_color = 'border-red-600' %}
14 |     {% set icon = '<svg fill="none" viewBox="0 0 24 24" stroke="currentColor" class="x w-8 h-8"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"/></svg>' %}
15 | {% elseif 'warning' == envelope.type %}
16 |     {% set title = 'Warning' %}
17 |     {% set text_color = 'text-yellow-700' %}
18 |     {% set background_color = 'bg-yellow-50' %}
19 |     {% set progress_background_color = 'bg-yellow-200' %}
20 |     {% set border_color = 'border-yellow-600' %}
21 |     {% set icon = '<svg fill="none" viewBox="0 0 24 24" stroke="currentColor" class="exclamation w-8 h-8"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"/></svg>' %}
22 | {% else %}
23 |     {% set title = 'Info' %}
24 |     {% set text_color = 'text-blue-700' %}
25 |     {% set background_color = 'bg-blue-50' %}
26 |     {% set progress_background_color = 'bg-blue-200' %}
27 |     {% set border_color = 'border-blue-600' %}
28 |     {% set icon = '<svg class="w-8 h-8" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" /></svg>' %}
29 | {% endif %}
30 | 
31 | <div class="bg-white shadow-lg border-l-4 mt-2 cursor-pointer {{ background_color }} {{ border_color }}">
32 |     <div class="flex items-center px-2 py-3 rounded-lg shadow-lg overflow-hidden">
33 |         <div class="inline-flex items-center p-2 text-white text-sm rounded-full {{ text_color }} flex-shrink-0">
34 |             {{ icon | raw }}
35 |         </div>
36 |         <div class="ml-4 w-0 flex-1">
37 |             <p class="text-base leading-5 font-medium capitalize {{ text_color }}">
38 |                 {{ title | trans }}
39 |             </p>
40 |             <p class="mt-1 text-sm leading-5 text-gray-500">
41 |                 {{ envelope.message }}
42 |             </p>
43 |         </div>
44 |     </div>
45 |     <div class="h-0.5 flex {{ background_color }}">
46 |         <span class="flasher-progress {{ progress_background_color }}"></span>
47 |     </div>
48 | </div>
49 | 


--------------------------------------------------------------------------------
/Resources/views/tailwindcss_r.html.twig:
--------------------------------------------------------------------------------
 1 | {% if 'success' == envelope.type %}
 2 |     {% set title = 'Success' %}
 3 |     {% set text_color = 'text-green-600' %}
 4 |     {% set ring_color = 'ring-green-300' %}
 5 |     {% set background_color = 'bg-green-600' %}
 6 |     {% set progress_background_color = 'bg-green-100' %}
 7 |     {% set border_color = 'border-green-600' %}
 8 |     {% set icon = '<svg fill="none" viewBox="0 0 24 24" stroke="currentColor" class="check w-8 h-8"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"/></svg>' %}
 9 | {% elseif 'error' == envelope.type %}
10 |     {% set title = 'Error' %}
11 |     {% set text_color = 'text-red-600' %}
12 |     {% set ring_color = 'ring-red-300' %}
13 |     {% set background_color = 'bg-red-600' %}
14 |     {% set progress_background_color = 'bg-red-100' %}
15 |     {% set border_color = 'border-red-600' %}
16 |     {% set icon = '<svg fill="none" viewBox="0 0 24 24" stroke="currentColor" class="x w-8 h-8"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"/></svg>' %}
17 | {% elseif 'warning' == envelope.type %}
18 |     {% set title = 'Warning' %}
19 |     {% set text_color = 'text-yellow-600' %}
20 |     {% set ring_color = 'ring-yellow-300' %}
21 |     {% set background_color = 'bg-yellow-600' %}
22 |     {% set progress_background_color = 'bg-yellow-100' %}
23 |     {% set border_color = 'border-yellow-600' %}
24 |     {% set icon = '<svg fill="none" viewBox="0 0 24 24" stroke="currentColor" class="exclamation w-8 h-8"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"/></svg>' %}
25 | {% else %}
26 |     {% set title = 'Info' %}
27 |     {% set text_color = 'text-blue-600' %}
28 |     {% set ring_color = 'ring-blue-300' %}
29 |     {% set background_color = 'bg-blue-600' %}
30 |     {% set progress_background_color = 'bg-blue-100' %}
31 |     {% set border_color = 'border-blue-600' %}
32 |     {% set icon = '<svg class="w-8 h-8" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" /></svg>' %}
33 | {% endif %}
34 | 
35 | 
36 | <div class="bg-white shadow-inner border-l-4 mt-2 cursor-pointer {{ border_color }}">
37 |     <div class="flex items-center px-2 py-3 rounded-lg shadow-lg overflow-hidden">
38 |         <div class="inline-flex items-center {{ text_color }} p-1 text-xl rounded-full flex-shrink-0">
39 |             {{ icon | raw }}
40 |         </div>
41 |         <div class="ml-4 w-0 flex-1">
42 |             <p class="text-base leading-5 font-medium capitalize {{ text_color }}">
43 |                 {{ title | trans }}
44 |             </p>
45 |             <p class="mt-1 text-sm leading-5 text-gray-500">
46 |                 {{ envelope.message }}
47 |             </p>
48 |         </div>
49 |     </div>
50 |     <div class="h-0.5 flex {{ progress_background_color }}">
51 |         <span class="flasher-progress {{ background_color }}"></span>
52 |     </div>
53 | </div>
54 | 


--------------------------------------------------------------------------------
/Storage/FallbackSession.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Flasher\Symfony\Storage;
 6 | 
 7 | /**
 8 |  * FallbackSession - In-memory session storage fallback.
 9 |  *
10 |  * This class provides a simple in-memory storage mechanism that can be used
11 |  * when the regular Symfony session is not available. It stores values in a
12 |  * static array, making them available for the duration of the request.
13 |  *
14 |  * Design patterns:
15 |  * - Null Object Pattern: Provides a non-failing alternative to a missing session
16 |  * - In-Memory Repository: Stores data in memory as a simple alternative to persistence
17 |  * - Singleton-like Pattern: Uses a static storage array shared across instances
18 |  */
19 | final class FallbackSession implements FallbackSessionInterface
20 | {
21 |     /**
22 |      * In-memory storage for session data.
23 |      *
24 |      * @var array<string, mixed>
25 |      */
26 |     private static array $storage = [];
27 | 
28 |     public function get(string $name, mixed $default = null): mixed
29 |     {
30 |         return \array_key_exists($name, self::$storage) ? self::$storage[$name] : $default;
31 |     }
32 | 
33 |     public function set(string $name, mixed $value): void
34 |     {
35 |         self::$storage[$name] = $value;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/Storage/FallbackSessionInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Flasher\Symfony\Storage;
 6 | 
 7 | /**
 8 |  * FallbackSessionInterface - Contract for alternative session storage.
 9 |  *
10 |  * This interface defines methods for a fallback storage mechanism when the
11 |  * regular Symfony session is not available. This is particularly useful in
12 |  * stateless contexts or when the session hasn't been started.
13 |  *
14 |  * Design patterns:
15 |  * - Interface Segregation: Defines a minimal interface for session-like storage
16 |  * - Strategy Pattern: Allows different storage implementations to be used
17 |  * - Fallback Strategy: Provides an alternative when primary storage is unavailable
18 |  */
19 | interface FallbackSessionInterface
20 | {
21 |     /**
22 |      * Retrieves a value from the fallback session storage.
23 |      *
24 |      * @param string $name    the name of the value
25 |      * @param mixed  $default the default value to return if the name is not found
26 |      *
27 |      * @return mixed the value from storage or default
28 |      */
29 |     public function get(string $name, mixed $default = null): mixed;
30 | 
31 |     /**
32 |      * Stores a value in the fallback session storage.
33 |      *
34 |      * @param string $name  the name of the value to store
35 |      * @param mixed  $value the value to store
36 |      */
37 |     public function set(string $name, mixed $value): void;
38 | }
39 | 


--------------------------------------------------------------------------------
/Storage/SessionBag.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Flasher\Symfony\Storage;
  6 | 
  7 | use Flasher\Prime\Notification\Envelope;
  8 | use Flasher\Prime\Storage\Bag\BagInterface;
  9 | use Symfony\Component\HttpFoundation\Exception\SessionNotFoundException;
 10 | use Symfony\Component\HttpFoundation\RequestStack;
 11 | use Symfony\Component\HttpFoundation\Session\SessionInterface;
 12 | 
 13 | /**
 14 |  * SessionBag - Symfony session storage for PHPFlasher notifications.
 15 |  *
 16 |  * This class implements PHPFlasher's storage interface using Symfony's session
 17 |  * system, providing persistence for notifications across requests. It includes
 18 |  * fallback behavior for stateless contexts.
 19 |  *
 20 |  * Design patterns:
 21 |  * - Adapter Pattern: Adapts Symfony's session to PHPFlasher's storage interface
 22 |  * - Strategy Pattern: Uses different storage strategies based on context
 23 |  * - Fallback Strategy: Falls back to in-memory storage when session unavailable
 24 |  * - Repository Pattern: Provides CRUD operations for notification storage
 25 |  */
 26 | final readonly class SessionBag implements BagInterface
 27 | {
 28 |     /**
 29 |      * Session key for storing notification envelopes.
 30 |      */
 31 |     public const ENVELOPES_NAMESPACE = 'flasher::envelopes';
 32 | 
 33 |     /**
 34 |      * Fallback storage for contexts where session is unavailable.
 35 |      */
 36 |     private FallbackSessionInterface $fallbackSession;
 37 | 
 38 |     /**
 39 |      * Creates a new SessionBag instance.
 40 |      *
 41 |      * @param RequestStack                  $requestStack    Symfony's request stack for accessing session
 42 |      * @param FallbackSessionInterface|null $fallbackSession Optional custom fallback storage
 43 |      */
 44 |     public function __construct(private RequestStack $requestStack, ?FallbackSessionInterface $fallbackSession = null)
 45 |     {
 46 |         $this->fallbackSession = $fallbackSession ?: new FallbackSession();
 47 |     }
 48 | 
 49 |     /**
 50 |      * {@inheritdoc}
 51 |      *
 52 |      * Gets all notification envelopes from storage.
 53 |      *
 54 |      * @return Envelope[] The stored notification envelopes
 55 |      */
 56 |     public function get(): array
 57 |     {
 58 |         $session = $this->getSession();
 59 | 
 60 |         /** @var Envelope[] $envelopes */
 61 |         $envelopes = $session->get(self::ENVELOPES_NAMESPACE, []);
 62 | 
 63 |         return $envelopes;
 64 |     }
 65 | 
 66 |     /**
 67 |      * {@inheritdoc}
 68 |      *
 69 |      * Stores notification envelopes in storage.
 70 |      *
 71 |      * @param array<Envelope> $envelopes The notification envelopes to store
 72 |      */
 73 |     public function set(array $envelopes): void
 74 |     {
 75 |         $session = $this->getSession();
 76 | 
 77 |         $session->set(self::ENVELOPES_NAMESPACE, $envelopes);
 78 |     }
 79 | 
 80 |     /**
 81 |      * Gets the appropriate session storage implementation.
 82 |      *
 83 |      * Uses Symfony session if available and request is not stateless,
 84 |      * otherwise falls back to the fallback session implementation.
 85 |      *
 86 |      * @return SessionInterface|FallbackSessionInterface The storage implementation
 87 |      */
 88 |     private function getSession(): SessionInterface|FallbackSessionInterface
 89 |     {
 90 |         try {
 91 |             $request = $this->requestStack->getCurrentRequest();
 92 | 
 93 |             if ($request && !$request->attributes->get('_stateless', false)) {
 94 |                 return $this->requestStack->getSession();
 95 |             }
 96 |         } catch (SessionNotFoundException) {
 97 |         }
 98 | 
 99 |         return $this->fallbackSession;
100 |     }
101 | }
102 | 


--------------------------------------------------------------------------------
/Support/PluginBundle.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Flasher\Symfony\Support;
  6 | 
  7 | use Flasher\Prime\Plugin\PluginInterface;
  8 | use Flasher\Symfony\FlasherSymfonyBundle;
  9 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 10 | use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
 11 | use Symfony\Component\HttpKernel\Bundle\AbstractBundle;
 12 | 
 13 | /**
 14 |  * PluginBundle - Base class for PHPFlasher plugin bundles.
 15 |  *
 16 |  * This abstract class provides common functionality for all PHPFlasher plugin bundles.
 17 |  * It extends Symfony's AbstractBundle to integrate with the kernel bundle system,
 18 |  * while implementing PluginBundleInterface to provide PHPFlasher-specific functionality.
 19 |  *
 20 |  * Design patterns:
 21 |  * - Template Method: Defines skeleton of common bundle operations
 22 |  * - Factory Method: Creates plugin instances
 23 |  * - Bridge: Connects Symfony bundle system with PHPFlasher plugin system
 24 |  * - Extension: Extends AbstractBundle with PHPFlasher-specific functionality
 25 |  */
 26 | abstract class PluginBundle extends AbstractBundle implements PluginBundleInterface
 27 | {
 28 |     /**
 29 |      * Creates an instance of the plugin.
 30 |      *
 31 |      * This factory method must be implemented by child classes to instantiate
 32 |      * the specific plugin that the bundle integrates.
 33 |      *
 34 |      * @return PluginInterface The plugin instance
 35 |      */
 36 |     abstract public function createPlugin(): PluginInterface;
 37 | 
 38 |     /**
 39 |      * Loads bundle configuration into the Symfony container.
 40 |      *
 41 |      * This method registers the plugin's factory service in the container and
 42 |      * configures it appropriately. The core FlasherSymfonyBundle is exempt from
 43 |      * this process since it has special handling.
 44 |      *
 45 |      * @param array<string, mixed>  $config    The processed bundle configuration
 46 |      * @param ContainerConfigurator $container The container configurator
 47 |      * @param ContainerBuilder      $builder   The container builder
 48 |      */
 49 |     public function loadExtension(array $config, ContainerConfigurator $container, ContainerBuilder $builder): void
 50 |     {
 51 |         if ($this instanceof FlasherSymfonyBundle) {
 52 |             return;
 53 |         }
 54 | 
 55 |         $plugin = $this->createPlugin();
 56 |         $identifier = $plugin->getServiceId();
 57 | 
 58 |         $container->services()
 59 |             ->set($identifier, $plugin->getFactory())
 60 |             ->parent('flasher.notification_factory')
 61 |             ->tag('flasher.factory', ['alias' => $plugin->getAlias()])
 62 |             ->public()
 63 |         ;
 64 | 
 65 |         foreach ((array) $plugin->getServiceAliases() as $alias) {
 66 |             $builder->setAlias($alias, $identifier);
 67 |         }
 68 |     }
 69 | 
 70 |     /**
 71 |      * Prepends default plugin configuration for Flasher.
 72 |      *
 73 |      * This method adds the plugin's scripts, styles, and options to the Flasher
 74 |      * configuration before the container is compiled.
 75 |      *
 76 |      * @param ContainerConfigurator $container The container configurator
 77 |      * @param ContainerBuilder      $builder   The container builder
 78 |      */
 79 |     public function prependExtension(ContainerConfigurator $container, ContainerBuilder $builder): void
 80 |     {
 81 |         if ($this instanceof FlasherSymfonyBundle) {
 82 |             return;
 83 |         }
 84 | 
 85 |         $plugin = $this->createPlugin();
 86 | 
 87 |         $builder->prependExtensionConfig('flasher', [
 88 |             'plugins' => [
 89 |                 $plugin->getAlias() => [
 90 |                     'scripts' => (array) $plugin->getScripts(),
 91 |                     'styles' => (array) $plugin->getStyles(),
 92 |                     'options' => $plugin->getOptions(),
 93 |                 ],
 94 |             ],
 95 |         ]);
 96 |     }
 97 | 
 98 |     /**
 99 |      * Gets the path to the plugin's configuration file.
100 |      *
101 |      * Returns the absolute path to the plugin's configuration file
102 |      * based on the bundle's path.
103 |      *
104 |      * @return string Absolute path to the configuration file
105 |      */
106 |     public function getConfigurationFile(): string
107 |     {
108 |         return rtrim($this->getPath(), '/').'/Resources/config/config.yaml';
109 |     }
110 | 
111 |     /**
112 |      * Gets the bundle's directory path.
113 |      *
114 |      * Uses reflection to determine the location of the bundle class file,
115 |      * then returns its directory.
116 |      *
117 |      * @return string The bundle directory path
118 |      */
119 |     public function getPath(): string
120 |     {
121 |         if (!isset($this->path)) {
122 |             $reflected = new \ReflectionObject($this);
123 |             // assume the modern directory structure by default
124 |             $this->path = \dirname($reflected->getFileName() ?: '');
125 |         }
126 | 
127 |         return $this->path;
128 |     }
129 | }
130 | 


--------------------------------------------------------------------------------
/Support/PluginBundleInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Flasher\Symfony\Support;
 6 | 
 7 | use Flasher\Prime\Plugin\PluginInterface;
 8 | 
 9 | /**
10 |  * PluginBundleInterface - Contract for PHPFlasher plugin bundles.
11 |  *
12 |  * This interface defines the basic requirements for a Symfony bundle that
13 |  * integrates a PHPFlasher plugin. It focuses on plugin creation and configuration.
14 |  *
15 |  * Design patterns:
16 |  * - Factory Method: Defines interface for creating plugin instances
17 |  * - Plugin Architecture: Supports extensible plugin system
18 |  * - Bridge: Connects Symfony bundle system with PHPFlasher plugin system
19 |  */
20 | interface PluginBundleInterface
21 | {
22 |     /**
23 |      * Creates an instance of the plugin.
24 |      *
25 |      * This factory method is responsible for instantiating the plugin that
26 |      * this bundle integrates with Symfony.
27 |      *
28 |      * @return PluginInterface The plugin instance
29 |      */
30 |     public function createPlugin(): PluginInterface;
31 | 
32 |     /**
33 |      * Gets the path to the plugin's configuration file.
34 |      *
35 |      * @return string Absolute path to the configuration file
36 |      */
37 |     public function getConfigurationFile(): string;
38 | }
39 | 


--------------------------------------------------------------------------------
/Template/TwigTemplateEngine.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Flasher\Symfony\Template;
 6 | 
 7 | use Flasher\Prime\Template\TemplateEngineInterface;
 8 | use Twig\Environment;
 9 | 
10 | /**
11 |  * TwigTemplateEngine - Adapter for Symfony's Twig template engine.
12 |  *
13 |  * This class adapts Symfony's Twig environment to PHPFlasher's template engine
14 |  * interface, enabling notification templates to be rendered using Twig.
15 |  *
16 |  * Design patterns:
17 |  * - Adapter Pattern: Adapts Twig to PHPFlasher's template interface
18 |  * - Null Object Pattern: Gracefully handles a missing Twig dependency
19 |  * - Bridge Pattern: Bridges PHPFlasher's templating needs with Symfony's templating system
20 |  */
21 | final readonly class TwigTemplateEngine implements TemplateEngineInterface
22 | {
23 |     /**
24 |      * Creates a new TwigTemplateEngine instance.
25 |      *
26 |      * @param Environment|null $twig The Twig environment or null if Twig is not available
27 |      */
28 |     public function __construct(private ?Environment $twig = null)
29 |     {
30 |     }
31 | 
32 |     /**
33 |      * Renders a template using Twig.
34 |      *
35 |      * @param string               $name    The template name or path
36 |      * @param array<string, mixed> $context The template variables
37 |      *
38 |      * @return string The rendered template
39 |      *
40 |      * @throws \LogicException If Twig is not available
41 |      */
42 |     public function render(string $name, array $context = []): string
43 |     {
44 |         if (null === $this->twig) {
45 |             throw new \LogicException('The TwigBundle is not registered in your application. Try running "composer require symfony/twig-bundle".');
46 |         }
47 | 
48 |         return $this->twig->render($name, $context);
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/Translation/Translator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Flasher\Symfony\Translation;
 6 | 
 7 | use Flasher\Prime\Translation\TranslatorInterface;
 8 | use Symfony\Component\Translation\TranslatorBagInterface;
 9 | use Symfony\Contracts\Translation\TranslatorInterface as SymfonyTranslatorInterface;
10 | 
11 | /**
12 |  * Translator - Adapter for Symfony's translation service.
13 |  *
14 |  * This class adapts Symfony's translation system to PHPFlasher's TranslatorInterface,
15 |  * enabling notification messages to be translated using Symfony's translation capabilities.
16 |  * It searches for messages in multiple domains with cascading fallbacks.
17 |  *
18 |  * Design patterns:
19 |  * - Adapter Pattern: Adapts Symfony's translator interface to PHPFlasher's interface
20 |  * - Facade Pattern: Simplifies the translation process with a unified interface
21 |  * - Chain of Responsibility: Tries multiple translation domains in sequence
22 |  */
23 | final readonly class Translator implements TranslatorInterface
24 | {
25 |     /**
26 |      * Creates a new Translator instance.
27 |      *
28 |      * @param SymfonyTranslatorInterface $translator The Symfony translator service
29 |      */
30 |     public function __construct(private SymfonyTranslatorInterface $translator)
31 |     {
32 |     }
33 | 
34 |     /**
35 |      * Translates a message using Symfony's translation system.
36 |      *
37 |      * This method attempts to translate the message in the following order:
38 |      * 1. In the 'flasher' domain (flasher-specific translations)
39 |      * 2. In the 'messages' domain (application-wide translations)
40 |      * 3. Returns the original ID if no translation is found
41 |      *
42 |      * @param string               $id         The message ID or key
43 |      * @param array<string, mixed> $parameters The translation parameters
44 |      * @param string|null          $locale     The locale or null to use the default
45 |      *
46 |      * @return string The translated string
47 |      */
48 |     public function translate(string $id, array $parameters = [], ?string $locale = null): string
49 |     {
50 |         if (!$this->translator instanceof TranslatorBagInterface) {
51 |             return $this->translator->trans($id, $parameters, 'flasher', $locale);
52 |         }
53 | 
54 |         $catalogue = $this->translator->getCatalogue($locale);
55 | 
56 |         foreach (['flasher', 'messages'] as $domain) {
57 |             if ($catalogue->has($id, $domain)) {
58 |                 return $this->translator->trans($id, $parameters, $domain, $locale);
59 |             }
60 |         }
61 | 
62 |         return $id;
63 |     }
64 | 
65 |     /**
66 |      * Gets the current locale from Symfony's translator.
67 |      *
68 |      * Falls back to system default locale if translator doesn't provide one.
69 |      *
70 |      * @return string The current locale code
71 |      */
72 |     public function getLocale(): string
73 |     {
74 |         if (method_exists($this->translator, 'getLocale')) { // @phpstan-ignore-line
75 |             return $this->translator->getLocale();
76 |         }
77 | 
78 |         return class_exists(\Locale::class) ? \Locale::getDefault() : 'en';
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/Twig/FlasherTwigExtension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Flasher\Symfony\Twig;
 6 | 
 7 | use Flasher\Prime\FlasherInterface;
 8 | use Twig\Extension\AbstractExtension;
 9 | use Twig\TwigFunction;
10 | 
11 | /**
12 |  * FlasherTwigExtension - Twig extension for rendering notifications.
13 |  *
14 |  * This class provides Twig functions that allow notification rendering
15 |  * directly from Twig templates. It exposes PHPFlasher's rendering
16 |  * capabilities to template files.
17 |  *
18 |  * Design patterns:
19 |  * - Extension Pattern: Extends Twig's functionality
20 |  * - Adapter Pattern: Adapts PHPFlasher's API for Twig templates
21 |  * - Delegation: Delegates actual rendering to the Flasher service
22 |  */
23 | final class FlasherTwigExtension extends AbstractExtension
24 | {
25 |     /**
26 |      * Creates a new FlasherTwigExtension instance.
27 |      *
28 |      * @param FlasherInterface $flasher The PHPFlasher service
29 |      */
30 |     public function __construct(private readonly FlasherInterface $flasher)
31 |     {
32 |     }
33 | 
34 |     /**
35 |      * Returns the Twig functions provided by this extension.
36 |      *
37 |      * @return TwigFunction[] Array of Twig functions
38 |      */
39 |     public function getFunctions(): array
40 |     {
41 |         return [
42 |             new TwigFunction('flasher_render', $this->render(...), ['is_safe' => ['html']]),
43 |         ];
44 |     }
45 | 
46 |     /**
47 |      * Renders the flash notifications based on the specified criteria, presenter, and context.
48 |      *
49 |      * @param array<string, mixed> $criteria  the criteria to filter the notifications
50 |      * @param "html"|"json"|string $presenter The presenter format for rendering the notifications (e.g., 'html', 'json').
51 |      * @param array<string, mixed> $context   additional context or options for rendering
52 |      *
53 |      * @return mixed The rendered output (HTML string, JSON string, etc.)
54 |      */
55 |     public function render(array $criteria = [], string $presenter = 'html', array $context = []): mixed
56 |     {
57 |         return $this->flasher->render($presenter, $criteria, $context);
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "php-flasher/flasher-symfony",
 3 |     "type": "symfony-bundle",
 4 |     "license": "MIT",
 5 |     "homepage": "https://php-flasher.io",
 6 |     "description": "Integrate flash notifications into Symfony projects effortlessly with PHPFlasher. Improve user experience and application feedback loops easily.",
 7 |     "keywords": [
 8 |         "symfony",
 9 |         "php",
10 |         "flash-notifications",
11 |         "phpflasher",
12 |         "user-feedback",
13 |         "open-source"
14 |     ],
15 |     "support": {
16 |         "issues": "https://github.com/php-flasher/php-flasher/issues",
17 |         "source": "https://github.com/php-flasher/php-flasher"
18 |     },
19 |     "authors": [
20 |         {
21 |             "name": "Younes ENNAJI",
22 |             "email": "younes.ennaji.pro@gmail.com",
23 |             "homepage": "https://www.linkedin.com/in/younes--ennaji/",
24 |             "role": "Developer"
25 |         }
26 |     ],
27 |     "minimum-stability": "dev",
28 |     "prefer-stable": true,
29 |     "require": {
30 |         "php": ">=8.2",
31 |         "php-flasher/flasher": "^2.1.6",
32 |         "symfony/config": "^7.0",
33 |         "symfony/console": "^7.0",
34 |         "symfony/dependency-injection": "^7.0",
35 |         "symfony/http-kernel": "^7.0"
36 |     },
37 |     "suggest": {
38 |         "symfony/translation": "To translate flash messages, title and presets",
39 |         "symfony/ux-twig-component": "To utilize and interact with flash messages components in Twig templates"
40 |     },
41 |     "autoload": {
42 |         "psr-4": {
43 |             "Flasher\\Symfony\\": ""
44 |         }
45 |     },
46 |     "config": {
47 |         "preferred-install": "dist",
48 |         "sort-packages": true
49 |     }
50 | }
51 | 


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