├── .gitignore
├── .php_cs.dist
├── Builder
    ├── Item.php
    ├── ItemInterface.php
    ├── ItemProcess.php
    ├── ItemProcessInterface.php
    ├── Menu.php
    └── MenuInterface.php
├── DependencyInjection
    ├── Configuration.php
    └── PdMenuExtension.php
├── Event
    └── PdMenuEvent.php
├── LICENSE
├── Locator
    └── MenuLocator.php
├── PdMenuBundle.php
├── README.md
├── Render
    ├── RenderInterface.php
    └── TwigRender.php
├── Resources
    ├── config
    │   └── services.yml
    └── views
    │   └── Default
    │       ├── menu.html.twig
    │       └── menuBase.html.twig
├── Twig
    └── MenuExtension.php
└── composer.json


/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor
2 | /composer.lock
3 | .php_cs.cache
4 | 


--------------------------------------------------------------------------------
/.php_cs.dist:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | $fileHeaderComment = <<<COMMENT
 4 | This file is part of the pd-admin pd-menu package.
 5 | 
 6 | @package     pd-menu
 7 | @license     LICENSE
 8 | @author      Ramazan APAYDIN <apaydin541@gmail.com>
 9 | @link        https://github.com/appaydin/pd-menu
10 | COMMENT;
11 | 
12 | $finder = PhpCsFixer\Finder::create()
13 |     ->in(__DIR__)
14 | ;
15 | 
16 | return PhpCsFixer\Config::create()
17 |     ->setRiskyAllowed(true)
18 |     ->setRules([
19 |         '@Symfony' => true,
20 |         '@Symfony:risky' => true,
21 |         'array_syntax' => ['syntax' => 'short'],
22 |         'header_comment' => ['header' => $fileHeaderComment, 'separate' => 'both', 'commentType' => 'PHPDoc'],
23 |         'linebreak_after_opening_tag' => true,
24 |         'mb_str_functions' => true,
25 |         'no_php4_constructor' => true,
26 |         'no_useless_else' => true,
27 |         'no_useless_return' => true,
28 |         'ordered_imports' => true,
29 |         'php_unit_strict' => true,
30 |         'phpdoc_order' => true,
31 |         'semicolon_after_instruction' => true,
32 |         'strict_comparison' => true,
33 |         'strict_param' => true,
34 |         'blank_line_after_namespace' => true,
35 |         'class_definition' => true,
36 |         'multiline_comment_opening_closing' => true,
37 |         'single_line_comment_style' => true,
38 |         'single_blank_line_before_namespace' => true,
39 |         'phpdoc_trim' => true,
40 |         'no_extra_consecutive_blank_lines' => true
41 |     ])
42 |     ->setFinder($finder)
43 |     ->setCacheFile(__DIR__.'.php_cs.cache')
44 | ;
45 | 


--------------------------------------------------------------------------------
/Builder/Item.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * This file is part of the pd-admin pd-menu package.
  5 |  *
  6 |  * @package     pd-menu
  7 |  * @license     LICENSE
  8 |  * @author      Ramazan APAYDIN <apaydin541@gmail.com>
  9 |  * @link        https://github.com/appaydin/pd-menu
 10 |  */
 11 | 
 12 | namespace Pd\MenuBundle\Builder;
 13 | 
 14 | /**
 15 |  * Menu Item Properties.
 16 |  *
 17 |  * @author Ramazan APAYDIN <apaydin541@gmail.com>
 18 |  */
 19 | class Item implements ItemInterface
 20 | {
 21 |     protected $id;
 22 |     protected string $label = '';
 23 |     protected string $labelAfterHtml = '';
 24 |     protected string $link = '';
 25 |     protected string $linkAfterHtml = '';
 26 |     protected $order;
 27 |     protected array $route = [];
 28 |     protected array $linkAttr = [];
 29 |     protected array $listAttr = [];
 30 |     protected array $childAttr = [];
 31 |     protected array $labelAttr = [];
 32 |     protected array $extra = [];
 33 |     protected array $roles = [];
 34 | 
 35 |     /**
 36 |      * @var ItemInterface[]
 37 |      */
 38 |     protected array $child = [];
 39 |     protected $parent;
 40 |     protected bool $event;
 41 | 
 42 |     public function __construct(string $id, $event)
 43 |     {
 44 |         $this->id = $id;
 45 |         $this->event = $event;
 46 |     }
 47 | 
 48 |     public function isEvent(): bool
 49 |     {
 50 |         return (int)$this->event;
 51 |     }
 52 | 
 53 |     public function getId(): ?string
 54 |     {
 55 |         return $this->id;
 56 |     }
 57 | 
 58 |     public function setId($id = null): ItemInterface
 59 |     {
 60 |         $this->id = $id;
 61 | 
 62 |         return $this;
 63 |     }
 64 | 
 65 |     public function getLabel(): string
 66 |     {
 67 |         return $this->label;
 68 |     }
 69 | 
 70 |     public function setLabel(string $label): ItemInterface
 71 |     {
 72 |         $this->label = $label;
 73 | 
 74 |         return $this;
 75 |     }
 76 | 
 77 |     public function getLabelAfterHtml(): string
 78 |     {
 79 |         return $this->labelAfterHtml;
 80 |     }
 81 | 
 82 |     public function setLabelAfterHtml(string $html): ItemInterface
 83 |     {
 84 |         $this->labelAfterHtml = $html;
 85 | 
 86 |         return $this;
 87 |     }
 88 | 
 89 |     public function getLink(): string
 90 |     {
 91 |         return $this->link;
 92 |     }
 93 | 
 94 |     public function setLink(string $link): ItemInterface
 95 |     {
 96 |         $this->link = $link;
 97 | 
 98 |         return $this;
 99 |     }
100 | 
101 |     public function getLinkAfterHtml(): string
102 |     {
103 |         return $this->linkAfterHtml;
104 |     }
105 | 
106 |     public function setLinkAfterHtml(string $html): ItemInterface
107 |     {
108 |         $this->linkAfterHtml = $html;
109 | 
110 |         return $this;
111 |     }
112 | 
113 |     public function getOrder(): int
114 |     {
115 |         return $this->order;
116 |     }
117 | 
118 |     public function setOrder(int $order): ItemInterface
119 |     {
120 |         $this->order = $order;
121 | 
122 |         return $this;
123 |     }
124 | 
125 |     public function getRoute(): array
126 |     {
127 |         return $this->route;
128 |     }
129 | 
130 |     public function setRoute(string $route, array $params = []): ItemInterface
131 |     {
132 |         $this->route = [
133 |             'name' => $route,
134 |             'params' => $params,
135 |         ];
136 | 
137 |         return $this;
138 |     }
139 | 
140 |     public function getLinkAttr(): array
141 |     {
142 |         return $this->linkAttr;
143 |     }
144 | 
145 |     public function setLinkAttr(array $linkAttr): ItemInterface
146 |     {
147 |         $this->linkAttr = array_merge($this->linkAttr, $linkAttr);
148 | 
149 |         return $this;
150 |     }
151 | 
152 |     public function getListAttr(): array
153 |     {
154 |         return $this->listAttr;
155 |     }
156 | 
157 |     public function setListAttr(array $listAttr): ItemInterface
158 |     {
159 |         $this->listAttr = array_merge($this->listAttr, $listAttr);
160 | 
161 |         return $this;
162 |     }
163 | 
164 |     public function getChildAttr(): array
165 |     {
166 |         return $this->childAttr;
167 |     }
168 | 
169 |     public function setChildAttr(array $childAttr): ItemInterface
170 |     {
171 |         $this->childAttr = array_merge($this->childAttr, $childAttr);
172 | 
173 |         return $this;
174 |     }
175 | 
176 |     public function getLabelAttr(): array
177 |     {
178 |         return $this->labelAttr;
179 |     }
180 | 
181 |     public function setLabelAttr(array $labelAttr): ItemInterface
182 |     {
183 |         $this->labelAttr = array_merge($this->labelAttr, $labelAttr);
184 | 
185 |         return $this;
186 |     }
187 | 
188 |     public function getExtra(string $name, $default = false)
189 |     {
190 |         if (\is_array($this->extra) && isset($this->extra[$name])) {
191 |             return $this->extra[$name];
192 |         }
193 | 
194 |         return $default;
195 |     }
196 | 
197 |     public function setExtra(string $name, $value): ItemInterface
198 |     {
199 |         if (\is_array($this->extra)) {
200 |             $this->extra[$name] = $value;
201 |         } else {
202 |             $this->extra = [$name => $value];
203 |         }
204 | 
205 |         return $this;
206 |     }
207 | 
208 |     public function getRoles(): array
209 |     {
210 |         return $this->roles;
211 |     }
212 | 
213 |     public function setRoles(array $roles): ItemInterface
214 |     {
215 |         $this->roles = array_merge($this->roles, $roles);
216 | 
217 |         return $this;
218 |     }
219 | 
220 |     public function getChild(): array
221 |     {
222 |         return $this->child;
223 |     }
224 | 
225 |     public function setChild(array $child): ItemInterface
226 |     {
227 |         $this->child = $child;
228 | 
229 |         return $this;
230 |     }
231 | 
232 |     public function addChild($child, $order = null): ItemInterface
233 |     {
234 |         // Create New Item
235 |         if (!$child instanceof ItemInterface) {
236 |             $child = new self($child, $this->event);
237 |         }
238 | 
239 |         // Child Set Parent & ID
240 |         $child
241 |             ->setOrder($order ?? \count($this->child))
242 |             ->setParent($this);
243 | 
244 |         // Add Child This
245 |         $this->child[$child->getId()] = $child;
246 | 
247 |         return $child;
248 |     }
249 | 
250 |     public function addChildParent($child, $order = null): ItemInterface
251 |     {
252 |         return $this->parent->addChild($child, $order);
253 |     }
254 | 
255 |     public function getParent(): ?ItemInterface
256 |     {
257 |         return $this->parent;
258 |     }
259 | 
260 |     public function setParent(ItemInterface $item): ItemInterface
261 |     {
262 |         if ($item === $this) {
263 |             throw new \InvalidArgumentException('Item cannot be a child of itself');
264 |         }
265 | 
266 |         $this->parent = $item;
267 | 
268 |         return $this;
269 |     }
270 | 
271 |     public function isRoot(): bool
272 |     {
273 |         return null === $this->parent;
274 |     }
275 | 
276 |     public function getLevel(): int
277 |     {
278 |         return $this->parent ? $this->parent->getLevel() + 1 : 0;
279 |     }
280 | 
281 |     public function offsetExists($childId)
282 |     {
283 |         return isset($this->child[$childId]);
284 |     }
285 | 
286 |     public function offsetGet($childId)
287 |     {
288 |         return $this->child[$childId];
289 |     }
290 | 
291 |     public function offsetSet($childId, $order)
292 |     {
293 |         return $this->addChild($childId, $order);
294 |     }
295 | 
296 |     public function offsetUnset($childId)
297 |     {
298 |         if ($this->offsetExists($childId)) {
299 |             unset($this->child[$childId]);
300 |         }
301 |     }
302 | }
303 | 


--------------------------------------------------------------------------------
/Builder/ItemInterface.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * This file is part of the pd-admin pd-menu package.
  5 |  *
  6 |  * @package     pd-menu
  7 |  * @license     LICENSE
  8 |  * @author      Ramazan APAYDIN <apaydin541@gmail.com>
  9 |  * @link        https://github.com/appaydin/pd-menu
 10 |  */
 11 | 
 12 | namespace Pd\MenuBundle\Builder;
 13 | 
 14 | /**
 15 |  * Menu Item Interface.
 16 |  *
 17 |  * @author Ramazan APAYDIN <apaydin541@gmail.com>
 18 |  */
 19 | interface ItemInterface extends \ArrayAccess
 20 | {
 21 |     /**
 22 |      * Menu Created Event.
 23 |      */
 24 |     public function isEvent(): bool;
 25 | 
 26 |     /**
 27 |      * Get Item Array ID | Order ID.
 28 |      */
 29 |     public function getId(): ?string;
 30 | 
 31 |     /**
 32 |      * Set Item Array ID | Order ID.
 33 |      */
 34 |     public function setId($id = null): self;
 35 | 
 36 |     /**
 37 |      * Get Menu Name.
 38 |      */
 39 |     public function getLabel(): string;
 40 | 
 41 |     /**
 42 |      * Change Name Menu Item.
 43 |      */
 44 |     public function setLabel(string $label): self;
 45 | 
 46 |     /**
 47 |      * Get Label After HTML.
 48 |      */
 49 |     public function getLabelAfterHtml(): string;
 50 | 
 51 |     /**
 52 |      * Label After Append HTML.
 53 |      */
 54 |     public function setLabelAfterHtml(string $html): self;
 55 | 
 56 |     /**
 57 |      * Get Menu Item URL.
 58 |      */
 59 |     public function getLink(): string;
 60 | 
 61 |     /**
 62 |      * Change Menu URL.
 63 |      */
 64 |     public function setLink(string $link): self;
 65 | 
 66 |     /**
 67 |      * Get Link After HTML.
 68 |      */
 69 |     public function getLinkAfterHtml(): string;
 70 | 
 71 |     /**
 72 |      * Label Link Append HTML.
 73 |      */
 74 |     public function setLinkAfterHtml(string $html): self;
 75 | 
 76 |     /**
 77 |      * Get Order Number.
 78 |      */
 79 |     public function getOrder(): int;
 80 | 
 81 |     /**
 82 |      * Set Order Number.
 83 |      */
 84 |     public function setOrder(int $order): self;
 85 | 
 86 |     /**
 87 |      * Get Menu Route Name.
 88 |      */
 89 |     public function getRoute(): array;
 90 | 
 91 |     /**
 92 |      * Change Menu Route.
 93 |      */
 94 |     public function setRoute(string $route, array $params = []): self;
 95 | 
 96 |     /**
 97 |      * Get Link Attributes "<a>".
 98 |      */
 99 |     public function getLinkAttr(): array;
100 | 
101 |     /**
102 |      * Set Link Attributes "<a>".
103 |      */
104 |     public function setLinkAttr(array $linkAttr): self;
105 | 
106 |     /**
107 |      * Get List Attributes "<li>".
108 |      */
109 |     public function getListAttr(): array;
110 | 
111 |     /**
112 |      * Set List Attributes "<li>".
113 |      */
114 |     public function setListAttr(array $listAttr): self;
115 | 
116 |     /**
117 |      * Get Child List Attributes "<ul>".
118 |      */
119 |     public function getChildAttr(): array;
120 | 
121 |     /**
122 |      * Set Child List Attributes "<ul>".
123 |      */
124 |     public function setChildAttr(array $childAttr): self;
125 | 
126 |     /**
127 |      * Get Label Attributes.
128 |      */
129 |     public function getLabelAttr(): array;
130 | 
131 |     /**
132 |      * Set Label Interface.
133 |      */
134 |     public function setLabelAttr(array $labelAttr): self;
135 | 
136 |     /**
137 |      * Get Extra Data Menu Item.
138 |      */
139 |     public function getExtra(string $name, $default = false);
140 | 
141 |     /**
142 |      * Set Extra Data Menu Item.
143 |      */
144 |     public function setExtra(string $name, $value): self;
145 | 
146 |     /**
147 |      * Get Access Roles Menu Item.
148 |      */
149 |     public function getRoles(): array;
150 | 
151 |     /**
152 |      * Set Access Roles Menu Item.
153 |      */
154 |     public function setRoles(array $roles): self;
155 | 
156 |     /**
157 |      * Get Child Items.
158 |      */
159 |     public function getChild(): array;
160 | 
161 |     /**
162 |      * Set Child Items.
163 |      */
164 |     public function setChild(array $child): self;
165 | 
166 |     /**
167 |      * Add Child.
168 |      */
169 |     public function addChild($child, $order = null): self;
170 | 
171 |     /**
172 |      * Add Child to Parent Item.
173 |      */
174 |     public function addChildParent($child, $order = null): self;
175 | 
176 |     /**
177 |      * Get Parent Menu Item.
178 |      *
179 |      * @return ItemInterface|null
180 |      */
181 |     public function getParent(): ?self;
182 | 
183 |     /**
184 |      * Set Parent Menu Item.
185 |      */
186 |     public function setParent(self $item): self;
187 | 
188 |     /**
189 |      * Check Menu is Root.
190 |      */
191 |     public function isRoot(): bool;
192 | 
193 |     /**
194 |      * Get Menu Level.
195 |      */
196 |     public function getLevel(): int;
197 | }
198 | 


--------------------------------------------------------------------------------
/Builder/ItemProcess.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * This file is part of the pd-admin pd-menu package.
  5 |  *
  6 |  * @package     pd-menu
  7 |  * @license     LICENSE
  8 |  * @author      Ramazan APAYDIN <apaydin541@gmail.com>
  9 |  * @link        https://github.com/appaydin/pd-menu
 10 |  */
 11 | 
 12 | namespace Pd\MenuBundle\Builder;
 13 | 
 14 | use Pd\MenuBundle\Event\PdMenuEvent;
 15 | use Symfony\Component\Routing\RouterInterface;
 16 | use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
 17 | use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
 18 | 
 19 | /**
 20 |  * Menu Item Processor.
 21 |  *
 22 |  * @author Ramazan APAYDIN <apaydin541@gmail.com>
 23 |  */
 24 | class ItemProcess implements ItemProcessInterface
 25 | {
 26 |     protected string $currentUri;
 27 | 
 28 |     public function __construct(
 29 |         private RouterInterface $router,
 30 |         private AuthorizationCheckerInterface $security,
 31 |         private EventDispatcherInterface $eventDispatcher)
 32 |     {
 33 |     }
 34 | 
 35 |     /**
 36 |      * Menu Processor.
 37 |      */
 38 |     public function processMenu(ItemInterface $menu, array $options = []): ItemInterface
 39 |     {
 40 |         // Dispatch Event
 41 |         if ($menu->isEvent()) {
 42 |             $this->eventDispatcher->dispatch(new PdMenuEvent($menu), $menu->getId().'.event');
 43 |         }
 44 | 
 45 |         // Set Current URI
 46 |         $this->currentUri = $this->router->getContext()->getPathInfo();
 47 | 
 48 |         // Process Menu
 49 |         $this->recursiveProcess($menu, $options);
 50 | 
 51 |         return $menu;
 52 |     }
 53 | 
 54 |     /**
 55 |      * Process Menu Item.
 56 |      */
 57 |     protected function recursiveProcess(ItemInterface $menu, $options): bool
 58 |     {
 59 |         // Get Child Menus
 60 |         $childs = $menu->getChild();
 61 |         $listActive = false;
 62 | 
 63 |         // Parent Menu Route
 64 |         if (isset($menu->getChildAttr()['data-parent'])) {
 65 |             $menu->setChildAttr(['data-parent' => $this->router->generate($menu->getChildAttr()['data-parent'])]);
 66 |         }
 67 | 
 68 |         // Sort Current Child
 69 |         foreach ($childs as $child) {
 70 |             $childActive = false;
 71 | 
 72 |             // Set Child Process
 73 |             if ($child->getChild()) {
 74 |                 // Set Menu Depth
 75 |                 if (null !== $options['depth'] && ($child->getLevel() >= $options['depth'])) {
 76 |                     $child->setChild([]);
 77 |                     break;
 78 |                 }
 79 | 
 80 |                 // Set Child List Class
 81 |                 $child->setChildAttr(array_merge_recursive($child->getChildAttr(), ['class' => 'menu_level_'.$child->getLevel()]));
 82 | 
 83 |                 $childActive = $this->recursiveProcess($child, $options);
 84 |             }
 85 | 
 86 |             // Generate Route Link
 87 |             if ($child->getRoute()) {
 88 |                 $child->setLink($this->router->generate($child->getRoute()['name'], $child->getRoute()['params']));
 89 |             }
 90 | 
 91 |             // Link Active Class
 92 |             if ($this->currentUri === $child->getLink() || $childActive) {
 93 |                 $listActive = true;
 94 |                 $child->setListAttr(array_merge_recursive($child->getListAttr(), ['class' => $options['currentClass']]));
 95 |             }
 96 | 
 97 |             // Item Security
 98 |             foreach ($child->getRoles() as $role) {
 99 |                 if (!$this->security->isGranted($role)) {
100 |                     unset($childs[$child->getId()]);
101 |                 }
102 |             }
103 |         }
104 | 
105 |         // Sort Item
106 |         usort($childs, static function ($a, $b) {
107 |             return $a->getOrder() > $b->getOrder() ? 1 : ($a->getOrder() === $b->getOrder() ? 0 : -1);
108 |         });
109 | 
110 |         // Set Childs
111 |         $menu->setChild($childs);
112 | 
113 |         return $listActive;
114 |     }
115 | }
116 | 


--------------------------------------------------------------------------------
/Builder/ItemProcessInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This file is part of the pd-admin pd-menu package.
 5 |  *
 6 |  * @package     pd-menu
 7 |  * @license     LICENSE
 8 |  * @author      Ramazan APAYDIN <apaydin541@gmail.com>
 9 |  * @link        https://github.com/appaydin/pd-menu
10 |  */
11 | 
12 | namespace Pd\MenuBundle\Builder;
13 | 
14 | /**
15 |  * Menu Item Processor Interface.
16 |  *
17 |  * @author Ramazan APAYDIN <apaydin541@gmail.com>
18 |  */
19 | interface ItemProcessInterface
20 | {
21 |     /**
22 |      * Item Processor.
23 |      */
24 |     public function processMenu(ItemInterface $menu, array $options = []): ItemInterface;
25 | }
26 | 


--------------------------------------------------------------------------------
/Builder/Menu.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This file is part of the pd-admin pd-menu package.
 5 |  *
 6 |  * @package     pd-menu
 7 |  * @license     LICENSE
 8 |  * @author      Ramazan APAYDIN <apaydin541@gmail.com>
 9 |  * @link        https://github.com/appaydin/pd-menu
10 |  */
11 | 
12 | namespace Pd\MenuBundle\Builder;
13 | 
14 | /**
15 |  * Menu Builder.
16 |  *
17 |  * @author Ramazan APAYDIN <apaydin541@gmail.com>
18 |  */
19 | class Menu implements MenuInterface
20 | {
21 |     /**
22 |      * Creating Menu.
23 |      */
24 |     public function createMenu(array $options = []): ItemInterface
25 |     {
26 |         return $this->createRoot('pd_menu');
27 |     }
28 | 
29 |     /**
30 |      * Create Menu Item.
31 |      */
32 |     final public function createRoot(string $name, $event = true): ItemInterface
33 |     {
34 |         return new Item($name, $event);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/Builder/MenuInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This file is part of the pd-admin pd-menu package.
 5 |  *
 6 |  * @package     pd-menu
 7 |  * @license     LICENSE
 8 |  * @author      Ramazan APAYDIN <apaydin541@gmail.com>
 9 |  * @link        https://github.com/appaydin/pd-menu
10 |  */
11 | 
12 | namespace Pd\MenuBundle\Builder;
13 | 
14 | /**
15 |  * Menu Interface.
16 |  *
17 |  * @author Ramazan APAYDIN <apaydin541@gmail.com>
18 |  */
19 | interface MenuInterface
20 | {
21 |     /**
22 |      * Create Menu.
23 |      */
24 |     public function createMenu(array $options = []): ItemInterface;
25 | 
26 |     /**
27 |      * Create Menu Item.
28 |      */
29 |     public function createRoot(string $name): ItemInterface;
30 | }
31 | 


--------------------------------------------------------------------------------
/DependencyInjection/Configuration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This file is part of the pd-admin pd-user package.
 5 |  *
 6 |  * @package     pd-user
 7 |  * @license     LICENSE
 8 |  * @author      Ramazan APAYDIN <apaydin541@gmail.com>
 9 |  * @link        https://github.com/appaydin/pd-user
10 |  */
11 | 
12 | namespace Pd\MenuBundle\DependencyInjection;
13 | 
14 | use Symfony\Component\Config\Definition\Builder\TreeBuilder;
15 | use Symfony\Component\Config\Definition\ConfigurationInterface;
16 | 
17 | class Configuration implements ConfigurationInterface
18 | {
19 |     public function getConfigTreeBuilder(): TreeBuilder
20 |     {
21 |         $treeBuilder = new TreeBuilder('pd_menu');
22 |         $rootNode = $treeBuilder->getRootNode();
23 | 
24 |         // Set Configuration
25 |         $rootNode
26 |             ->children()
27 |                 ->scalarNode('template')->defaultValue('@PdMenu/Default/menu.html.twig')->end()
28 |                 ->scalarNode('depth')->defaultValue(null)->end()
29 |                 ->scalarNode('currentClass')->defaultValue('active')->end()
30 |                 ->scalarNode('trans_domain')->defaultValue(null)->end()
31 |                 ->scalarNode('iconTemplate')->defaultValue('<i class="material-icons">&text</i>')->end()
32 |             ->end();
33 | 
34 |         return $treeBuilder;
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/DependencyInjection/PdMenuExtension.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This file is part of the pd-admin pd-menu package.
 5 |  *
 6 |  * @package     pd-menu
 7 |  * @license     LICENSE
 8 |  * @author      Ramazan APAYDIN <apaydin541@gmail.com>
 9 |  * @link        https://github.com/appaydin/pd-menu
10 |  */
11 | 
12 | namespace Pd\MenuBundle\DependencyInjection;
13 | 
14 | use Pd\MenuBundle\Builder\MenuInterface;
15 | use Pd\MenuBundle\Locator\MenuLocator;
16 | use Symfony\Component\Config\FileLocator;
17 | use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
18 | use Symfony\Component\DependencyInjection\ContainerBuilder;
19 | use Symfony\Component\DependencyInjection\Loader;
20 | use Symfony\Component\DependencyInjection\Reference;
21 | use Symfony\Component\HttpKernel\DependencyInjection\Extension;
22 | 
23 | /**
24 |  * This is the class that loads and manages your bundle configuration.
25 |  *
26 |  * @see http://symfony.com/doc/current/cookbook/bundles/extension.html
27 |  */
28 | class PdMenuExtension extends Extension implements CompilerPassInterface
29 | {
30 |     /**
31 |      * {@inheritdoc}
32 |      */
33 |     public function load(array $configs, ContainerBuilder $container)
34 |     {
35 |         // Load Menu Service Locator
36 |         $container->registerForAutoconfiguration(MenuInterface::class)->addTag('menus');
37 | 
38 |         // Load Configuration
39 |         $configuration = new Configuration();
40 |         $config = $this->processConfiguration($configuration, $configs);
41 | 
42 |         // Set Configuration
43 |         $container->setParameter('pd_menu', $config);
44 | 
45 |         // Load Services
46 |         $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
47 |         $loader->load('services.yml');
48 |     }
49 | 
50 |     public function process(ContainerBuilder $container)
51 |     {
52 |         $menuIds = [];
53 |         foreach ($container->findTaggedServiceIds('menus') as $id => $tags) {
54 |             $menuIds[$id] = new Reference($id);
55 |         }
56 |         $menuLocator = $container->getDefinition(MenuLocator::class);
57 |         $menuLocator->setArguments([$menuIds]);
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/Event/PdMenuEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This file is part of the pd-admin pd-menu package.
 5 |  *
 6 |  * @package     pd-menu
 7 |  * @license     LICENSE
 8 |  * @author      Ramazan APAYDIN <apaydin541@gmail.com>
 9 |  * @link        https://github.com/appaydin/pd-menu
10 |  */
11 | 
12 | namespace Pd\MenuBundle\Event;
13 | 
14 | use Pd\MenuBundle\Builder\ItemInterface;
15 | use Symfony\Contracts\EventDispatcher\Event;
16 | 
17 | /**
18 |  * Menu Event.
19 |  *
20 |  * @author Ramazan APAYDIN <apaydin541@gmail.com>
21 |  */
22 | class PdMenuEvent extends Event
23 | {
24 |     public function __construct(
25 |         private ItemInterface $menu)
26 |     {
27 |     }
28 | 
29 |     public function getMenu(): ItemInterface
30 |     {
31 |         return $this->menu;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 Ramazan APAYDIN
 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 | 


--------------------------------------------------------------------------------
/Locator/MenuLocator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Pd\MenuBundle\Locator;
 4 | 
 5 | use Symfony\Component\DependencyInjection\ServiceLocator;
 6 | 
 7 | class MenuLocator extends ServiceLocator
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/PdMenuBundle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This file is part of the pd-admin pd-menu package.
 5 |  *
 6 |  * @package     pd-menu
 7 |  * @license     LICENSE
 8 |  * @author      Ramazan APAYDIN <apaydin541@gmail.com>
 9 |  * @link        https://github.com/appaydin/pd-menu
10 |  */
11 | 
12 | namespace Pd\MenuBundle;
13 | 
14 | use Symfony\Component\HttpKernel\Bundle\Bundle;
15 | 
16 | class PdMenuBundle extends Bundle
17 | {
18 | }
19 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # pdMenu Bundle
  2 | Simple fast object-oriented menu maker for Symfony 5
  3 | 
  4 | [![Packagist](https://img.shields.io/packagist/dt/appaydin/pd-menu.svg)](https://github.com/appaydin/pd-menu)
  5 | [![Github Release](https://img.shields.io/github/release/appaydin/pd-menu.svg)](https://github.com/appaydin/pd-menu)
  6 | [![license](https://img.shields.io/github/license/appaydin/pd-menu.svg)](https://github.com/appaydin/pd-menu)
  7 | [![PHP from Packagist](https://img.shields.io/packagist/php-v/appaydin/pd-menu.svg)](https://github.com/appaydin/pd-menu)
  8 | 
  9 | Installation
 10 | ---
 11 | 
 12 | #### Step 1: Download the Bundle
 13 | 
 14 | Open a command console, enter your project directory and execute the
 15 | following command to download the latest stable version of this bundle:
 16 | 
 17 | ```console
 18 | composer require appaydin/pd-menu
 19 | ```
 20 | 
 21 | This command requires you to have Composer installed globally, as explained
 22 | in the [installation chapter](https://getcomposer.org/doc/00-intro.md)
 23 | of the Composer documentation.
 24 | 
 25 | #### Step 2: Enable the Bundle
 26 | 
 27 | With Symfony 4, the package will be activated automatically. But if something goes wrong, you can install it manually.
 28 | 
 29 | Then, enable the bundle by adding it to the list of registered bundles
 30 | in the `config/bundles.php` file of your project:
 31 | 
 32 | ```php
 33 | <?php
 34 | // config/bundles.php
 35 | 
 36 | return [
 37 |     //...
 38 |     Pd\MenuBundle\PdMenuBundle::class => ['all' => true]
 39 | ];
 40 | ```
 41 | 
 42 | Create Your First menu
 43 | ---
 44 | 
 45 | #### Step 1: Without Service
 46 | You can create menus without service. You can load the necessary parameters using `$options`
 47 | 
 48 | ```php
 49 | <?php
 50 | // src/Menu/FirstMenu.php
 51 | 
 52 | namespace App\Menu;
 53 | 
 54 | use Pd\MenuBundle\Builder\ItemInterface;
 55 | use Pd\MenuBundle\Builder\Menu;
 56 | 
 57 | class FirstMenu extends Menu
 58 | {
 59 |     /**
 60 |      * Override
 61 |      */
 62 |     public function createMenu(array $options = []): ItemInterface
 63 |     {
 64 |         // Create Root Item
 65 |         $menu = $this
 66 |             ->createRoot('settings_menu', true) // Create event is "settings_menu.event"
 67 |             ->setChildAttr(['data-parent' => 'admin_account_list']); // Add Parent Menu to Html Tag
 68 | 
 69 |         // Create Menu Items
 70 |         $menu->addChild('nav_config_general', 1)
 71 |             ->setLabel('nav_config_general')
 72 |             ->setRoute('admin_settings_general')
 73 |             ->setLinkAttr(['class' => 'nav-item'])
 74 |             ->setRoles(['ADMIN_SETTINGS_GENERAL'])
 75 |                 // Contact
 76 |                 ->addChildParent('nav_config_contact', 5)
 77 |                 ->setLabel('nav_config_contact')
 78 |                 ->setRoute('admin_settings_contact')
 79 |                 ->setLinkAttr(['class' => 'nav-item'])
 80 |                 ->setRoles(['ADMIN_SETTINGS_CONTACT'])
 81 |                 // Email
 82 |                 ->addChildParent('nav_config_email', 10)
 83 |                 ->setLabel('nav_config_email')
 84 |                 ->setRoute('admin_settings_email')
 85 |                 ->setLinkAttr(['class' => 'nav-item'])
 86 |                 ->setRoles(['ADMIN_SETTINGS_EMAIL'])
 87 |                 // Template
 88 |                 ->addChildParent('nav_config_template')
 89 |                 ->setLabel('nav_config_template')
 90 |                 ->setRoute('admin_settings_template')
 91 |                 ->setLinkAttr(['class' => 'nav-item'])
 92 |                 ->setRoles(['ADMIN_SETTINGS_TEMPLATE'])
 93 |                 // Account
 94 |                 ->addChildParent('nav_config_user')
 95 |                 ->setLabel('nav_config_user')
 96 |                 ->setRoute('admin_settings_user')
 97 |                 ->setLinkAttr(['class' => 'nav-item'])
 98 |                 ->setRoles(['ADMIN_SETTINGS_USER']);
 99 | 
100 |         return $menu;
101 |     }
102 | }
103 | ```
104 | 
105 | Rendering Menu
106 | ---
107 | The creation process is very simple. You can specify additional options.
108 | 
109 | ```twig
110 | {{ pd_menu_render('App\\Menu\\FirstMenu', {
111 |     'custom': 'variable or options'
112 | }) }}
113 | ```
114 | 
115 | You can change the default options.
116 | ```twig
117 | {{ pd_menu_render('App\\Menu\\FirstMenu', {
118 |     'template': '@PdMenu/Default/menu.html.twig',
119 |     'depth': null,
120 |     'currentClass': 'active',
121 |     'trans_domain': 'admin',
122 |     'iconTemplate' => '<i class="material-icons">itext</i>'
123 | }) }}
124 | ```
125 | 
126 | You can change the default options globally.
127 | 
128 | ```twig
129 | config/packages/pd_menu.yaml
130 | 
131 | pd_menu:
132 |     template: '@PdMenu/Default/menu.html.twig',
133 |     depth: null,
134 |     currentClass: active
135 |     trans_domain: admin,
136 |     iconTemplate: '<i class="fa&text"></i>'
137 | ```
138 | 
139 | Create Menu Event & Event Listener
140 | ---
141 | #### Step 1: Create Menu Event
142 | All menus automatic events are generated. Example : "menu_name.event"
143 | 
144 | #### Step 2: Create Menu Listener
145 | Now let's create a listener for the event.
146 | ```php
147 | <?php
148 | // src/Listener/MenuListener.php
149 | 
150 | namespace App\Listener;
151 | 
152 | use Pd\MenuBundle\Event\PdMenuEvent;
153 | 
154 | class MenuListener
155 | {
156 |     public function onCreate(PdMenuEvent $event)
157 |     {
158 |         // Get Menu Items
159 |         $menu = $event->getMenu();
160 | 
161 |         // Add New Item
162 |         $menu->addChild('demo_item', 5)
163 |             ->setLabel('Home Page')
164 |             ->setRoute('home_route');
165 |     }
166 | }
167 | ```
168 | Let's create a service for the listener.
169 | ```yaml
170 | App\Menu\MenuListener:
171 |     tags:
172 |         - { name: kernel.event_listener, event: settings_menu.event, method: onCreate }
173 | ```
174 | 
175 | 
176 | 


--------------------------------------------------------------------------------
/Render/RenderInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This file is part of the pd-admin pd-menu package.
 5 |  *
 6 |  * @package     pd-menu
 7 |  * @license     LICENSE
 8 |  * @author      Ramazan APAYDIN <apaydin541@gmail.com>
 9 |  * @link        https://github.com/appaydin/pd-menu
10 |  */
11 | 
12 | namespace Pd\MenuBundle\Render;
13 | 
14 | use Pd\MenuBundle\Builder\ItemInterface;
15 | 
16 | /**
17 |  * Render Interface.
18 |  *
19 |  * @author Ramazan APAYDIN <apaydin541@gmail.com>
20 |  */
21 | interface RenderInterface
22 | {
23 |     /**
24 |      * Render Menu.
25 |      */
26 |     public function render(ItemInterface $item, array $options = []): string;
27 | }
28 | 


--------------------------------------------------------------------------------
/Render/TwigRender.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * This file is part of the pd-admin pd-menu package.
 5 |  *
 6 |  * @package     pd-menu
 7 |  * @license     LICENSE
 8 |  * @author      Ramazan APAYDIN <apaydin541@gmail.com>
 9 |  * @link        https://github.com/appaydin/pd-menu
10 |  */
11 | 
12 | namespace Pd\MenuBundle\Render;
13 | 
14 | use Pd\MenuBundle\Builder\ItemInterface;
15 | use Twig\Environment;
16 | 
17 | /**
18 |  * Menu Twig Rendering.
19 |  *
20 |  * @author Ramazan APAYDIN <apaydin541@gmail.com>
21 |  */
22 | class TwigRender implements RenderInterface
23 | {
24 |     public function __construct(
25 |         private Environment $engine)
26 |     {
27 |     }
28 | 
29 |     public function render(ItemInterface $item, array $options = []): string
30 |     {
31 |         return $this->engine->render($options['template'], ['menu' => $item, 'options' => $options]);
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/Resources/config/services.yml:
--------------------------------------------------------------------------------
 1 | services:
 2 |     _defaults:
 3 |         autowire: true      # Automatically injects dependencies in your services.
 4 |         autoconfigure: true # Automatically registers your services as commands, event subscribers, etc.
 5 |         public: false       # Allows optimizing the container by removing unused services; this also means
 6 | 
 7 |     # makes classes in src/ available to be used as services
 8 |     # this creates a service per class whose id is the fully-qualified class name
 9 |     Pd\MenuBundle\:
10 |         resource: '../../*'
11 |         exclude: '../../{Entity,Migrations,Tests,Kernel.php}'
12 | 


--------------------------------------------------------------------------------
/Resources/views/Default/menu.html.twig:
--------------------------------------------------------------------------------
 1 | {% extends '@PdMenu/Default/menuBase.html.twig' %}
 2 | 
 3 | {# Begin Menu #}
 4 | {% block menu_begin %}
 5 |     <ul id="{{ menu.id }}" {{ arrayToAttr(menu.childAttr, {'class': 'pd-menu'}, options) }}>
 6 |         {% for depth in menu.child %}
 7 |             {% set menu = depth %}
 8 |             {{ block('menu_item') }}
 9 |         {% endfor %}
10 |     </ul>
11 | {% endblock %}
12 | 
13 | {# Create Menu Item #}
14 | {% block menu_item %}
15 |     {% set dropdown = menu.child|length > 0 %}
16 |     <li {{ arrayToAttr(menu.listAttr, {'class': dropdown ? 'dropdown' : '', 'data-id': menu.id}, options) }}>
17 |         {# Create Link #}
18 |         {% if menu.link %}
19 |             <a href="{{ menu.link }}" {{ arrayToAttr(menu.linkAttr, [], options) }}>
20 |                 {% if menu.extra('label_icon') %}
21 |                     {{ options.iconTemplate|replace({ '&text': menu.extra('label_icon') })|raw }}
22 |                 {% endif %}
23 |                 <span {{ arrayToAttr(menu.labelAttr, [], options) }}>
24 |                     {{ menu.extra('label_translate', true) ? menu.label|trans([], options.trans_domain)|raw : menu.label|raw }}
25 |                 </span>
26 |                 {{ menu.labelAfterHtml|raw }}
27 |             </a>
28 |             {{ menu.linkAfterHtml|raw }}
29 |         {% else %}
30 |             {% if menu.extra('label_icon') %}
31 |                 {{ options.iconTemplate|replace({ '&text': menu.extra('label_icon') })|raw }}
32 |             {% endif %}
33 |             <span {{ arrayToAttr(menu.labelAttr, [], options) }}>
34 |                     {{ menu.extra('label_translate', true) ? menu.label|trans([], options.trans_domain)|raw : menu.label|raw }}
35 |             </span>
36 |             {{ menu.labelAfterHtml|raw }}
37 |             {{ menu.linkAfterHtml|raw }}
38 |         {% endif %}
39 | 
40 |         {# Create Dropdown #}
41 |         {% if menu.child|length %}
42 |             <ul {{ arrayToAttr(menu.childAttr, [], options) }}>
43 |                 {% for depth in menu.child %}
44 |                     {% set menu = depth %}
45 |                     {{ block('menu_item') }}
46 |                 {% endfor %}
47 |             </ul>
48 |         {% endif %}
49 |     </li>
50 | {% endblock %}
51 | 


--------------------------------------------------------------------------------
/Resources/views/Default/menuBase.html.twig:
--------------------------------------------------------------------------------
1 | {# Render First Block #}
2 | {{ block('menu_begin') }}
3 | 


--------------------------------------------------------------------------------
/Twig/MenuExtension.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /**
  4 |  * This file is part of the pd-admin pd-menu package.
  5 |  *
  6 |  * @package     pd-menu
  7 |  * @license     LICENSE
  8 |  * @author      Ramazan APAYDIN <apaydin541@gmail.com>
  9 |  * @link        https://github.com/appaydin/pd-menu
 10 |  */
 11 | 
 12 | namespace Pd\MenuBundle\Twig;
 13 | 
 14 | use Pd\MenuBundle\Builder\ItemInterface;
 15 | use Pd\MenuBundle\Builder\ItemProcessInterface;
 16 | use Pd\MenuBundle\Builder\MenuInterface;
 17 | use Pd\MenuBundle\Locator\MenuLocator;
 18 | use Pd\MenuBundle\Render\RenderInterface;
 19 | use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
 20 | use Symfony\Contracts\Translation\TranslatorInterface;
 21 | use Twig\Extension\AbstractExtension;
 22 | use Twig\TwigFunction;
 23 | 
 24 | /**
 25 |  * Menu Twig Extension.
 26 |  *
 27 |  * @author Ramazan APAYDIN <apaydin541@gmail.com>
 28 |  */
 29 | class MenuExtension extends AbstractExtension
 30 | {
 31 |     public function __construct(
 32 |         private RenderInterface $engine,
 33 |         private ItemProcessInterface $itemProcess,
 34 |         private TranslatorInterface $translator,
 35 |         private ParameterBagInterface $parameterBag,
 36 |         private MenuLocator $menuLocator
 37 |     )
 38 |     {
 39 |     }
 40 | 
 41 |     /**
 42 |      * Create Twig Function.
 43 |      */
 44 |     public function getFunctions(): array
 45 |     {
 46 |         return [
 47 |             new TwigFunction('pd_menu_render', [$this, 'renderMenu'], ['is_safe' => ['html']]),
 48 |             new TwigFunction('pd_menu_get', [$this, 'getMenu']),
 49 |             new TwigFunction('arrayToAttr', [$this, 'arrayToAttr'], ['is_safe' => ['html']]),
 50 |         ];
 51 |     }
 52 | 
 53 |     /**
 54 |      * Render Menu.
 55 |      */
 56 |     public function renderMenu(string $menuClass = '', array $options = []): ?string
 57 |     {
 58 |         // Merge Options
 59 |         $options = array_merge($this->parameterBag->get('pd_menu'), $options);
 60 | 
 61 |         // Get Menu
 62 |         $menu = $this->menuLocator->get($menuClass);
 63 | 
 64 |         // Render
 65 |         if ($menu instanceof MenuInterface) {
 66 |             // Process Menu
 67 |             $menu = $this->itemProcess->processMenu($menu->createMenu($options), $options);
 68 | 
 69 |             return $this->engine->render($menu, $options);
 70 |         }
 71 | 
 72 |         return null;
 73 |     }
 74 | 
 75 |     /**
 76 |      * Get Menu Array.
 77 |      */
 78 |     public function getMenu(string $menuClass, array $options = []): ?ItemInterface
 79 |     {
 80 |         // Merge Options
 81 |         $options = array_merge($this->parameterBag->get('pd_menu'), $options);
 82 | 
 83 |         // Get Menu
 84 |         $menu = $this->menuLocator->get($menuClass);
 85 | 
 86 |         // Render
 87 |         if ($menu instanceof MenuInterface) {
 88 |             return $this->itemProcess->processMenu($menu->createMenu($options), $options);
 89 |         }
 90 | 
 91 |         return null;
 92 |     }
 93 | 
 94 |     /**
 95 |      * Array to Html Attr Convert.
 96 |      */
 97 |     public function arrayToAttr(array $array = [], array $append = [], array $options = []): string
 98 |     {
 99 |         $array = array_merge_recursive($array, $append);
100 |         $attr = '';
101 | 
102 |         foreach ($array as $key => $value) {
103 |             if (\is_array($value)) {
104 |                 $value = implode(' ', $value);
105 |             }
106 | 
107 |             if (('title' === mb_strtolower($key)) && !isset($array['title_translate'])) {
108 |                 $value = $this->translator->trans($value, [],
109 |                     $options['trans_domain'] ?? $this->parameterBag->get('pd_menu')['trans_domain']);
110 |             }
111 | 
112 |             $attr .= sprintf('%s="%s" ', $key, $value);
113 |         }
114 | 
115 |         return trim($attr);
116 |     }
117 | }
118 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "appaydin/pd-menu",
 3 |   "description": "Symfony Simple Menu Bundle",
 4 |   "homepage": "https://github.com/appaydin/pd-menu",
 5 |   "type": "symfony-bundle",
 6 |   "license": "MIT",
 7 |   "keywords": [
 8 |     "pd-admin",
 9 |     "pd-menu",
10 |     "menu",
11 |     "symfony-menu"
12 |   ],
13 |   "authors": [
14 |     {
15 |       "name": "Ramazan APAYDIN",
16 |       "homepage": "https://github.com/appaydin"
17 |     }
18 |   ],
19 |   "require": {
20 |     "php": ">=8.0.0",
21 |     "twig/twig": "*",
22 |     "symfony/event-dispatcher": "*"
23 |   },
24 |   "autoload": {
25 |     "psr-4": {
26 |       "Pd\\MenuBundle\\": ""
27 |     }
28 |   }
29 | }
30 | 


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