AbstractMenuContentObject.php

Go to the documentation of this file.

<?php
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Frontend\ContentObject\Menu;
 
use ‪TYPO3\CMS\Core\Cache\CacheManager;
use ‪TYPO3\CMS\Core\Context\Context;
use ‪TYPO3\CMS\Core\Context\LanguageAspect;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Database\RelationHandler;
use ‪TYPO3\CMS\Core\Domain\Repository\PageRepository;
use ‪TYPO3\CMS\Core\Exception\SiteNotFoundException;
use ‪TYPO3\CMS\Core\Site\Entity\NullSite;
use ‪TYPO3\CMS\Core\Site\Entity\SiteInterface;
use ‪TYPO3\CMS\Core\Site\SiteFinder;
use ‪TYPO3\CMS\Core\TimeTracker\TimeTracker;
use ‪TYPO3\CMS\Core\TypoScript\TemplateService;
use ‪TYPO3\CMS\Core\TypoScript\TypoScriptService;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Frontend\ContentObject\ContentObjectRenderer;
use ‪TYPO3\CMS\Frontend\ContentObject\Menu\Exception\NoSuchMenuTypeException;
use ‪TYPO3\CMS\Frontend\Controller\TypoScriptFrontendController;
use ‪TYPO3\CMS\Frontend\Typolink\PageLinkBuilder;
 
abstract class ‪AbstractMenuContentObject
{
    protected ‪$menuNumber = 1;
 
    protected ‪$entryLevel = 0;
 
    protected ‪$excludedDoktypes = [‪PageRepository::DOKTYPE_BE_USER_SECTION, ‪PageRepository::DOKTYPE_SYSFOLDER];
 
    protected ‪$alwaysActivePIDlist = [];
 
    public ‪$parent_cObj;
 
    protected ‪$MP_array = [];
 
    protected ‪$conf = [];
 
    protected ‪$mconf = [];
 
    protected ‪$tmpl;
 
    protected ‪$sys_page;
 
    protected ‪$id;
 
    protected ‪$nextActive;
 
    protected ‪$menuArr;
 
    protected ‪$hash;
 
    protected ‪$result = [];
 
    protected ‪$rL_uidRegister;
 
    protected ‪$I;
 
    protected ‪$WMresult;
 
    protected ‪$WMmenuItems;
 
    protected ‪$WMsubmenuObjSuffixes;
 
    protected ‪$WMcObj;
 
    protected ‪$alternativeMenuTempArray = '';
 
    protected ‪$parentMenuArrItemKey;
 
    protected ‪$parentMenuArr;
 
    protected const ‪customItemStates = [
        // IFSUB is TRUE if there exist submenu items to the current item
        'IFSUB',
        'ACT',
        // ACTIFSUB is TRUE if there exist submenu items to the current item and the current item is active
        'ACTIFSUB',
        // CUR is TRUE if the current page equals the item here!
        'CUR',
        // CURIFSUB is TRUE if there exist submenu items to the current item and the current page equals the item here!
        'CURIFSUB',
        'USR',
        'SPC',
        'USERDEF1',
        'USERDEF2'
    ];
 
    public function ‪start(‪$tmpl, ‪$sys_page, ‪$id, ‪$conf, ‪$menuNumber, $objSuffix = '')
    {
        $tsfe = $this->‪getTypoScriptFrontendController();
        $this->conf = ‪$conf;
        $this->menuNumber = ‪$menuNumber;
        $this->mconf = ‪$conf[$this->menuNumber . $objSuffix . '.'];
        $this->WMcObj = GeneralUtility::makeInstance(ContentObjectRenderer::class);
        // Sets the internal vars. $tmpl MUST be the template-object. $sys_page MUST be the PageRepository object
        if ($this->conf[$this->menuNumber . $objSuffix] && is_object(‪$tmpl) && is_object(‪$sys_page)) {
            $this->tmpl = ‪$tmpl;
            $this->sys_page = ‪$sys_page;
            // alwaysActivePIDlist initialized:
            if (trim($this->conf['alwaysActivePIDlist']) || isset($this->conf['alwaysActivePIDlist.'])) {
                if (isset($this->conf['alwaysActivePIDlist.'])) {
                    $this->conf['alwaysActivePIDlist'] = $this->parent_cObj->stdWrap(
                        $this->conf['alwaysActivePIDlist'],
                        $this->conf['alwaysActivePIDlist.']
                    );
                }
                $this->alwaysActivePIDlist = ‪GeneralUtility::intExplode(',', $this->conf['alwaysActivePIDlist']);
            }
            // includeNotInMenu initialized:
            $includeNotInMenu = $this->conf['includeNotInMenu'];
            $includeNotInMenuConf = $this->conf['includeNotInMenu.'] ?? null;
            $this->conf['includeNotInMenu'] = is_array($includeNotInMenuConf)
                ? $this->parent_cObj->stdWrap($includeNotInMenu, $includeNotInMenuConf)
                : $includeNotInMenu;
            // exclude doktypes that should not be shown in menu (e.g. backend user section)
            if ($this->conf['excludeDoktypes'] ?? false) {
                $this->excludedDoktypes = ‪GeneralUtility::intExplode(',', $this->conf['excludeDoktypes']);
            }
            // EntryLevel
            $this->entryLevel = $this->parent_cObj->getKey(
                isset(‪$conf['entryLevel.']) ? $this->parent_cObj->stdWrap(
                    ‪$conf['entryLevel'],
                    ‪$conf['entryLevel.']
                ) : ‪$conf['entryLevel'],
                $this->tmpl->rootLine
            );
            // Set parent page: If $id not stated with start() then the base-id will be found from rootLine[$this->entryLevel]
            // Called as the next level in a menu. It is assumed that $this->MP_array is set from parent menu.
            if (‪$id) {
                $this->id = (int)‪$id;
            } else {
                // This is a BRAND NEW menu, first level. So we take ID from rootline and also find MP_array (mount points)
                $this->id = (int)$this->tmpl->rootLine[$this->entryLevel]['uid'];
                // Traverse rootline to build MP_array of pages BEFORE the entryLevel
                // (MP var for ->id is picked up in the next part of the code...)
                foreach ($this->tmpl->rootLine as ‪$entryLevel => $levelRec) {
                    // For overlaid mount points, set the variable right now:
                    if (($levelRec['_MP_PARAM'] ?? false) && ($levelRec['_MOUNT_OL'] ?? false)) {
                        $this->MP_array[] = $levelRec['_MP_PARAM'];
                    }
                    // Break when entry level is reached:
                    if (‪$entryLevel >= $this->entryLevel) {
                        break;
                    }
                    // For normal mount points, set the variable for next level.
                    if ($levelRec['_MP_PARAM'] && !$levelRec['_MOUNT_OL']) {
                        $this->MP_array[] = $levelRec['_MP_PARAM'];
                    }
                }
            }
            // Return FALSE if no page ID was set (thus no menu of subpages can be made).
            if ($this->id <= 0) {
                return false;
            }
            // Check if page is a mount point, and if so set id and MP_array
            // (basically this is ONLY for non-overlay mode, but in overlay mode an ID with a mount point should never reach this point anyways, so no harm done...)
            $mount_info = $this->sys_page->getMountPointInfo($this->id);
            if (is_array($mount_info)) {
                $this->MP_array[] = $mount_info['MPvar'];
                $this->id = $mount_info['mount_pid'];
            }
            // Gather list of page uids in root line (for "isActive" evaluation). Also adds the MP params in the path so Mount Points are respected.
            // (List is specific for this rootline, so it may be supplied from parent menus for speed...)
            if ($this->rL_uidRegister === null) {
                $this->rL_uidRegister = [];
                $rl_MParray = [];
                foreach ($this->tmpl->rootLine as $v_rl) {
                    // For overlaid mount points, set the variable right now:
                    if (($v_rl['_MP_PARAM'] ?? false) && ($v_rl['_MOUNT_OL'] ?? false)) {
                        $rl_MParray[] = $v_rl['_MP_PARAM'];
                    }
                    // Add to register:
                    $this->rL_uidRegister[] = 'ITEM:' . $v_rl['uid'] .
                        (
                            !empty($rl_MParray)
                            ? ':' . implode(',', $rl_MParray)
                            : ''
                        );
                    // For normal mount points, set the variable for next level.
                    if (($v_rl['_MP_PARAM'] ?? false) && !($v_rl['_MOUNT_OL'] ?? false)) {
                        $rl_MParray[] = $v_rl['_MP_PARAM'];
                    }
                }
            }
            // Set $directoryLevel so the following evaluation of the nextActive will not return
            // an invalid value if .special=directory was set
            $directoryLevel = 0;
            if ($this->conf['special'] === 'directory') {
                $value = isset($this->conf['special.']['value.']) ? $this->parent_cObj->stdWrap(
                    $this->conf['special.']['value'],
                    $this->conf['special.']['value.']
                ) : $this->conf['special.']['value'];
                if ($value === '') {
                    $value = $tsfe->page['uid'];
                }
                $directoryLevel = (int)$tsfe->tmpl->getRootlineLevel($value);
            }
            // Setting "nextActive": This is the page uid + MPvar of the NEXT page in rootline. Used to expand the menu if we are in the right branch of the tree
            // Notice: The automatic expansion of a menu is designed to work only when no "special" modes (except "directory") are used.
            $startLevel = $directoryLevel ?: ‪$this->entryLevel;
            $currentLevel = $startLevel + ‪$this->menuNumber;
            if (is_array($this->tmpl->rootLine[$currentLevel] ?? null)) {
                $nextMParray = ‪$this->MP_array;
                if (empty($nextMParray) && !$this->tmpl->rootLine[$currentLevel]['_MOUNT_OL'] && $currentLevel > 0) {
                    // Make sure to slide-down any mount point information (_MP_PARAM) to children records in the rootline
                    // otherwise automatic expansion will not work
                    $parentRecord = $this->tmpl->rootLine[$currentLevel - 1];
                    if (isset($parentRecord['_MP_PARAM'])) {
                        $nextMParray[] = $parentRecord['_MP_PARAM'];
                    }
                }
                // In overlay mode, add next level MPvars as well:
                if ($this->tmpl->rootLine[$currentLevel]['_MOUNT_OL']) {
                    $nextMParray[] = $this->tmpl->rootLine[$currentLevel]['_MP_PARAM'];
                }
                $this->nextActive = $this->tmpl->rootLine[$currentLevel]['uid'] .
                    (
                        !empty($nextMParray)
                        ? ':' . implode(',', $nextMParray)
                        : ''
                    );
            } else {
                $this->nextActive = '';
            }
            return true;
        }
        $this->‪getTimeTracker()->‪setTSlogMessage('ERROR in menu', 3);
        return false;
    }
 
    public function ‪makeMenu()
    {
        if (!$this->id) {
            return;
        }
 
        // Initializing showAccessRestrictedPages
        $SAVED_where_groupAccess = '';
        if ($this->mconf['showAccessRestrictedPages'] ?? false) {
            // SAVING where_groupAccess
            $SAVED_where_groupAccess = $this->sys_page->where_groupAccess;
            // Temporarily removing fe_group checking!
            $this->sys_page->where_groupAccess = '';
        }
 
        $menuItems = $this->‪prepareMenuItems();
 
        $c = 0;
        $c_b = 0;
 
        $minItems = (int)(($this->mconf['minItems'] ?? 0) ?: ($this->conf['minItems'] ?? 0));
        $maxItems = (int)(($this->mconf['maxItems'] ?? 0) ?: ($this->conf['maxItems'] ?? 0));
        $begin = $this->parent_cObj->calc(($this->mconf['begin'] ?? 0) ?: ($this->conf['begin'] ?? 0));
        $minItemsConf = $this->mconf['minItems.'] ?? $this->conf['minItems.'] ?? null;
        $minItems = is_array($minItemsConf) ? $this->parent_cObj->stdWrap($minItems, $minItemsConf) : $minItems;
        $maxItemsConf = $this->mconf['maxItems.'] ?? $this->conf['maxItems.'] ?? null;
        $maxItems = is_array($maxItemsConf) ? $this->parent_cObj->stdWrap($maxItems, $maxItemsConf) : $maxItems;
        $beginConf = $this->mconf['begin.'] ?? $this->conf['begin.'] ?? null;
        $begin = is_array($beginConf) ? $this->parent_cObj->stdWrap($begin, $beginConf) : $begin;
        $banUidArray = $this->‪getBannedUids();
        // Fill in the menuArr with elements that should go into the menu:
        $this->menuArr = [];
        foreach ($menuItems as $data) {
            $isSpacerPage = (int)$data['doktype'] === ‪PageRepository::DOKTYPE_SPACER || $data['ITEM_STATE'] === 'SPC';
            // if item is a spacer, $spacer is set
            if ($this->‪filterMenuPages($data, $banUidArray, $isSpacerPage)) {
                $c_b++;
                // If the beginning item has been reached.
                if ($begin <= $c_b) {
                    $this->menuArr[$c] = $this->‪determineOriginalShortcutPage($data);
                    $this->menuArr[$c]['isSpacer'] = $isSpacerPage;
                    $c++;
                    if ($maxItems && $c >= $maxItems) {
                        break;
                    }
                }
            }
        }
        // Fill in fake items, if min-items is set.
        if ($minItems) {
            while ($c < $minItems) {
                $this->menuArr[$c] = [
                    'title' => '...',
                    'uid' => $this->‪getTypoScriptFrontendController()->id
                ];
                $c++;
            }
        }
        //  Passing the menuArr through a user defined function:
        if ($this->mconf['itemArrayProcFunc'] ?? false) {
            $this->menuArr = $this->‪userProcess('itemArrayProcFunc', $this->menuArr);
        }
        // Setting number of menu items
        $this->‪getTypoScriptFrontendController()->register['count_menuItems'] = count($this->menuArr);
        $this->hash = md5(
            json_encode($this->menuArr) .
            json_encode($this->mconf) .
            json_encode($this->tmpl->rootLine) .
            json_encode($this->MP_array)
        );
        // Get the cache timeout:
        if ($this->conf['cache_period'] ?? false) {
            $cacheTimeout = $this->conf['cache_period'];
        } else {
            $cacheTimeout = $this->‪getTypoScriptFrontendController()->‪get_cache_timeout();
        }
        $cache = $this->‪getCache();
        $cachedData = $cache->get($this->hash);
        if (!is_array($cachedData)) {
            $this->‪generate();
            $cache->set($this->hash, $this->result, ['ident_MENUDATA'], (int)$cacheTimeout);
        } else {
            $this->result = $cachedData;
        }
        // End showAccessRestrictedPages
        if ($this->mconf['showAccessRestrictedPages'] ?? false) {
            // RESTORING where_groupAccess
            $this->sys_page->where_groupAccess = $SAVED_where_groupAccess;
        }
    }
 
    public function ‪generate()
    {
    }
 
    public function ‪writeMenu()
    {
        return '';
    }
 
    protected function ‪removeInaccessiblePages(array $pages)
    {
        $banned = $this->‪getBannedUids();
        $filteredPages = [];
        foreach ($pages as $aPage) {
            if ($this->‪filterMenuPages($aPage, $banned, (int)$aPage['doktype'] === ‪PageRepository::DOKTYPE_SPACER)) {
                $filteredPages[$aPage['uid']] = $aPage;
            }
        }
        return $filteredPages;
    }
 
    protected function ‪prepareMenuItems()
    {
        $menuItems = [];
        $alternativeSortingField = trim($this->mconf['alternativeSortingField'] ?? '') ?: 'sorting';
 
        // Additional where clause, usually starts with AND (as usual with all additionalWhere functionality in TS)
        $additionalWhere = $this->mconf['additionalWhere'] ?? '';
        if (isset($this->mconf['additionalWhere.'])) {
            $additionalWhere = $this->parent_cObj->stdWrap($additionalWhere, $this->mconf['additionalWhere.']);
        }
        $additionalWhere .= $this->‪getDoktypeExcludeWhere();
 
        // ... only for the FIRST level of a HMENU
        if ($this->menuNumber == 1 && $this->conf['special']) {
            $value = isset($this->conf['special.']['value.'])
                ? $this->parent_cObj->stdWrap($this->conf['special.']['value'], $this->conf['special.']['value.'])
                : $this->conf['special.']['value'];
            switch ($this->conf['special']) {
                case 'userfunction':
                    $menuItems = $this->‪prepareMenuItemsForUserSpecificMenu($value, $alternativeSortingField);
                    break;
                case 'language':
                    $menuItems = $this->‪prepareMenuItemsForLanguageMenu($value);
                    break;
                case 'directory':
                    $menuItems = $this->‪prepareMenuItemsForDirectoryMenu($value, $alternativeSortingField);
                    break;
                case 'list':
                    $menuItems = $this->prepareMenuItemsForListMenu($value);
                    break;
                case 'updated':
                    $menuItems = $this->‪prepareMenuItemsForUpdatedMenu(
                        $value,
                        $this->mconf['alternativeSortingField'] ?: false
                    );
                    break;
                case 'keywords':
                    $menuItems = $this->‪prepareMenuItemsForKeywordsMenu(
                        $value,
                        $this->mconf['alternativeSortingField'] ?: false
                    );
                    break;
                case 'categories':
                    $categoryMenuUtility = GeneralUtility::makeInstance(CategoryMenuUtility::class);
                    $menuItems = $categoryMenuUtility->collectPages($value, $this->conf['special.'], $this);
                    break;
                case 'rootline':
                    $menuItems = $this->‪prepareMenuItemsForRootlineMenu();
                    break;
                case 'browse':
                    $menuItems = $this->‪prepareMenuItemsForBrowseMenu($value, $alternativeSortingField, $additionalWhere);
                    break;
            }
            if ($this->mconf['sectionIndex'] ?? false) {
                $sectionIndexes = [];
                foreach ($menuItems as $page) {
                    $sectionIndexes = $sectionIndexes + $this->‪sectionIndex($alternativeSortingField, $page['uid']);
                }
                $menuItems = $sectionIndexes;
            }
        } elseif (is_array($this->alternativeMenuTempArray)) {
            // Setting $menuItems array if not level 1.
            $menuItems = ‪$this->alternativeMenuTempArray;
        } elseif ($this->mconf['sectionIndex']) {
            $menuItems = $this->‪sectionIndex($alternativeSortingField);
        } else {
            // Default: Gets a hierarchical menu based on subpages of $this->id
            $menuItems = $this->sys_page->getMenu($this->id, '*', $alternativeSortingField, $additionalWhere);
        }
        return $menuItems;
    }
 
    protected function ‪prepareMenuItemsForUserSpecificMenu($specialValue, $sortingField)
    {
        $menuItems = $this->parent_cObj->callUserFunction(
            $this->conf['special.']['userFunc'],
            array_merge($this->conf['special.'], ['value' => $specialValue, '_altSortField' => $sortingField]),
            ''
        );
        return is_array($menuItems) ? $menuItems : [];
    }
 
    protected function ‪prepareMenuItemsForLanguageMenu($specialValue)
    {
        $menuItems = [];
        // Getting current page record NOT overlaid by any translation:
        $tsfe = $this->‪getTypoScriptFrontendController();
        $currentPageWithNoOverlay = $this->sys_page->getRawRecord('pages', $tsfe->page['uid']);
 
        if ($specialValue === 'auto') {
            $site = $this->‪getCurrentSite();
            $languages = $site->getLanguages();
            ‪$languageItems = array_keys($languages);
        } else {
            ‪$languageItems = ‪GeneralUtility::intExplode(',', $specialValue);
        }
 
        $tsfe->register['languages_HMENU'] = implode(',', ‪$languageItems);
 
        $currentLanguageId = $this->‪getCurrentLanguageAspect()->getId();
 
        foreach (‪$languageItems as $sUid) {
            // Find overlay record:
            if ($sUid) {
                $lRecs = $this->sys_page->getPageOverlay($tsfe->page['uid'], $sUid);
            } else {
                $lRecs = [];
            }
            // Checking if the "disabled" state should be set.
            if (GeneralUtility::hideIfNotTranslated($tsfe->page['l18n_cfg']) && $sUid &&
                empty($lRecs) || GeneralUtility::hideIfDefaultLanguage($tsfe->page['l18n_cfg']) &&
                (!$sUid || empty($lRecs)) ||
                !($this->conf['special.']['normalWhenNoLanguage'] ?? false) && $sUid && empty($lRecs)
            ) {
                $iState = $currentLanguageId === $sUid ? 'USERDEF2' : 'USERDEF1';
            } else {
                $iState = $currentLanguageId === $sUid ? 'ACT' : 'NO';
            }
            $getVars = '';
            if ($this->conf['addQueryString']) {
                $getVars = $this->parent_cObj->getQueryArguments(
                    $this->conf['addQueryString.'],
                    [],
                    true
                );
            }
            // Adding menu item:
            $menuItems[] = array_merge(
                array_merge($currentPageWithNoOverlay, $lRecs),
                [
                    '_PAGES_OVERLAY_REQUESTEDLANGUAGE' => $sUid,
                    'ITEM_STATE' => $iState,
                    '_ADD_GETVARS' => $getVars,
                    '_SAFE' => true
                ]
            );
        }
        return $menuItems;
    }
 
    protected function ‪prepareMenuItemsForDirectoryMenu($specialValue, $sortingField)
    {
        $tsfe = $this->‪getTypoScriptFrontendController();
        $menuItems = [];
        if ($specialValue == '') {
            $specialValue = $tsfe->page['uid'];
        }
        $items = ‪GeneralUtility::intExplode(',', $specialValue);
        $pageLinkBuilder = GeneralUtility::makeInstance(PageLinkBuilder::class, $this->parent_cObj);
        foreach ($items as ‪$id) {
            $MP = $pageLinkBuilder->getMountPointParameterFromRootPointMaps(‪$id);
            // Checking if a page is a mount page and if so, change the ID and set the MP var properly.
            $mount_info = $this->sys_page->getMountPointInfo(‪$id);
            if (is_array($mount_info)) {
                if ($mount_info['overlay']) {
                    // Overlays should already have their full MPvars calculated:
                    $MP = $pageLinkBuilder->getMountPointParameterFromRootPointMaps((int)$mount_info['mount_pid']);
                    $MP = $MP ?: $mount_info['MPvar'];
                } else {
                    $MP = ($MP ? $MP . ',' : '') . $mount_info['MPvar'];
                }
                ‪$id = $mount_info['mount_pid'];
            }
            // Get sub-pages:
            $statement = $this->parent_cObj->exec_getQuery('pages', ['pidInList' => ‪$id, 'orderBy' => $sortingField]);
            while ($row = $statement->fetch()) {
                // When the site language configuration is in "free" mode, then the page without overlay is fetched
                // (which is kind-of strange for pages, but this is what exec_getQuery() is doing)
                // this means, that $row is a translated page, but hasn't been overlaid. For this reason, we fetch
                // the default translation page again, (which does a ->getPageOverlay() again - doing this on a
                // translated page would result in no record at all)
                if ($row['l10n_parent'] > 0 && !isset($row['_PAGES_OVERLAY'])) {
                    $row = $this->sys_page->getPage($row['l10n_parent'], true);
                }
                $tsfe->sys_page->versionOL('pages', $row, true);
                if (!empty($row)) {
                    // Keep mount point?
                    $mount_info = $this->sys_page->getMountPointInfo($row['uid'], $row);
                    // There is a valid mount point.
                    if (is_array($mount_info) && $mount_info['overlay']) {
                        // Using "getPage" is OK since we need the check for enableFields
                        // AND for type 2 of mount pids we DO require a doktype < 200!
                        $mp_row = $this->sys_page->getPage($mount_info['mount_pid']);
                        if (!empty($mp_row)) {
                            $row = $mp_row;
                            $row['_MP_PARAM'] = $mount_info['MPvar'];
                        } else {
                            // If the mount point could not be fetched with respect
                            // to enableFields, unset the row so it does not become a part of the menu!
                            unset($row);
                        }
                    }
                    // Add external MP params, then the row:
                    if (!empty($row)) {
                        if ($MP) {
                            $row['_MP_PARAM'] = $MP . ($row['_MP_PARAM'] ? ',' . $row['_MP_PARAM'] : '');
                        }
                        $menuItems[] = $this->sys_page->getPageOverlay($row);
                    }
                }
            }
        }
 
        return $menuItems;
    }
 
    protected function prepareMenuItemsForListMenu($specialValue)
    {
        $menuItems = [];
        if ($specialValue == '') {
            $specialValue = ‪$this->id;
        }
        $skippedEnableFields = [];
        if (!empty($this->mconf['showAccessRestrictedPages'])) {
            $skippedEnableFields = ['fe_group' => 1];
        }
        $loadDB = GeneralUtility::makeInstance(RelationHandler::class);
        $loadDB->setFetchAllFields(true);
        $loadDB->start($specialValue, 'pages');
        $loadDB->additionalWhere['pages'] = $this->sys_page->enableFields('pages', -1, $skippedEnableFields);
        $loadDB->getFromDB();
        $pageLinkBuilder = GeneralUtility::makeInstance(PageLinkBuilder::class, $this->parent_cObj);
        foreach ($loadDB->itemArray as $val) {
            $MP = $pageLinkBuilder->getMountPointParameterFromRootPointMaps((int)$val['id']);
            // Keep mount point?
            $mount_info = $this->sys_page->getMountPointInfo($val['id']);
            // There is a valid mount point.
            if (is_array($mount_info) && $mount_info['overlay']) {
                // Using "getPage" is OK since we need the check for enableFields
                // AND for type 2 of mount pids we DO require a doktype < 200!
                $mp_row = $this->sys_page->getPage($mount_info['mount_pid']);
                if (!empty($mp_row)) {
                    $row = $mp_row;
                    $row['_MP_PARAM'] = $mount_info['MPvar'];
                    // Overlays should already have their full MPvars calculated
                    if ($mount_info['overlay']) {
                        $MP = $pageLinkBuilder->getMountPointParameterFromRootPointMaps((int)$mount_info['mount_pid']);
                        if ($MP) {
                            unset($row['_MP_PARAM']);
                        }
                    }
                } else {
                    // If the mount point could not be fetched with respect to
                    // enableFields, unset the row so it does not become a part of the menu!
                    unset($row);
                }
            } else {
                $row = $loadDB->results['pages'][$val['id']];
            }
            // Add versioning overlay for current page (to respect workspaces)
            if (isset($row) && is_array($row)) {
                $this->sys_page->versionOL('pages', $row, true);
            }
            // Add external MP params, then the row:
            if (isset($row) && is_array($row)) {
                if ($MP) {
                    $row['_MP_PARAM'] = $MP . ($row['_MP_PARAM'] ? ',' . $row['_MP_PARAM'] : '');
                }
                $menuItems[] = $this->sys_page->getPageOverlay($row);
            }
        }
        return $menuItems;
    }
 
    protected function ‪prepareMenuItemsForUpdatedMenu($specialValue, $sortingField)
    {
        $tsfe = $this->‪getTypoScriptFrontendController();
        $menuItems = [];
        if ($specialValue == '') {
            $specialValue = $tsfe->page['uid'];
        }
        $items = ‪GeneralUtility::intExplode(',', $specialValue);
        if (‪MathUtility::canBeInterpretedAsInteger($this->conf['special.']['depth'])) {
            $depth = ‪MathUtility::forceIntegerInRange($this->conf['special.']['depth'], 1, 20);
        } else {
            $depth = 20;
        }
        // Max number of items
        $limit = ‪MathUtility::forceIntegerInRange($this->conf['special.']['limit'], 0, 100);
        $maxAge = (int)$this->parent_cObj->calc($this->conf['special.']['maxAge']);
        if (!$limit) {
            $limit = 10;
        }
        // 'auto', 'manual', 'tstamp'
        $mode = $this->conf['special.']['mode'];
        // Get id's
        $beginAtLevel = ‪MathUtility::forceIntegerInRange($this->conf['special.']['beginAtLevel'], 0, 100);
        $id_list_arr = [];
        foreach ($items as ‪$id) {
            // Exclude the current ID if beginAtLevel is > 0
            if ($beginAtLevel > 0) {
                $id_list_arr[] = $this->parent_cObj->getTreeList(‪$id, $depth - 1 + $beginAtLevel, $beginAtLevel - 1);
            } else {
                $id_list_arr[] = $this->parent_cObj->getTreeList(-1 * ‪$id, $depth - 1 + $beginAtLevel, $beginAtLevel - 1);
            }
        }
        $id_list = implode(',', $id_list_arr);
        // Get sortField (mode)
        switch ($mode) {
            case 'starttime':
                $sortField = 'starttime';
                break;
            case 'lastUpdated':
            case 'manual':
                $sortField = 'lastUpdated';
                break;
            case 'tstamp':
                $sortField = 'tstamp';
                break;
            case 'crdate':
                $sortField = 'crdate';
                break;
            default:
                $sortField = 'SYS_LASTCHANGED';
        }
        $extraWhere = ($this->conf['includeNotInMenu'] ? '' : ' AND pages.nav_hide=0') . $this->‪getDoktypeExcludeWhere();
        if ($this->conf['special.']['excludeNoSearchPages']) {
            $extraWhere .= ' AND pages.no_search=0';
        }
        if ($maxAge > 0) {
            $extraWhere .= ' AND ' . $sortField . '>' . (‪$GLOBALS['SIM_ACCESS_TIME'] - $maxAge);
        }
        $statement = $this->parent_cObj->exec_getQuery('pages', [
            'pidInList' => '0',
            'uidInList' => $id_list,
            'where' => $sortField . '>=0' . $extraWhere,
            'orderBy' => $sortingField ?: $sortField . ' DESC',
            'max' => $limit
        ]);
        while ($row = $statement->fetch()) {
            // When the site language configuration is in "free" mode, then the page without overlay is fetched
            // (which is kind-of strange for pages, but this is what exec_getQuery() is doing)
            // this means, that $row is a translated page, but hasn't been overlaid. For this reason, we fetch
            // the default translation page again, (which does a ->getPageOverlay() again - doing this on a
            // translated page would result in no record at all)
            if ($row['l10n_parent'] > 0 && !isset($row['_PAGES_OVERLAY'])) {
                $row = $this->sys_page->getPage($row['l10n_parent'], true);
            }
            $tsfe->sys_page->versionOL('pages', $row, true);
            if (is_array($row)) {
                $menuItems[$row['uid']] = $this->sys_page->getPageOverlay($row);
            }
        }
 
        return $menuItems;
    }
 
    protected function ‪prepareMenuItemsForKeywordsMenu($specialValue, $sortingField)
    {
        $tsfe = $this->‪getTypoScriptFrontendController();
        $menuItems = [];
        [$specialValue] = ‪GeneralUtility::intExplode(',', $specialValue);
        if (!$specialValue) {
            $specialValue = $tsfe->page['uid'];
        }
        if ($this->conf['special.']['setKeywords'] || $this->conf['special.']['setKeywords.']) {
            $kw = isset($this->conf['special.']['setKeywords.']) ? $this->parent_cObj->stdWrap($this->conf['special.']['setKeywords'], $this->conf['special.']['setKeywords.']) : $this->conf['special.']['setKeywords'];
        } else {
            // The page record of the 'value'.
            $value_rec = $this->sys_page->getPage($specialValue);
            $kfieldSrc = $this->conf['special.']['keywordsField.']['sourceField'] ?: 'keywords';
            // keywords.
            $kw = trim($this->parent_cObj->keywords($value_rec[$kfieldSrc]));
        }
        // *'auto', 'manual', 'tstamp'
        $mode = $this->conf['special.']['mode'];
        switch ($mode) {
            case 'starttime':
                $sortField = 'starttime';
                break;
            case 'lastUpdated':
            case 'manual':
                $sortField = 'lastUpdated';
                break;
            case 'tstamp':
                $sortField = 'tstamp';
                break;
            case 'crdate':
                $sortField = 'crdate';
                break;
            default:
                $sortField = 'SYS_LASTCHANGED';
        }
        // Depth, limit, extra where
        if (‪MathUtility::canBeInterpretedAsInteger($this->conf['special.']['depth'])) {
            $depth = ‪MathUtility::forceIntegerInRange($this->conf['special.']['depth'], 0, 20);
        } else {
            $depth = 20;
        }
        // Max number of items
        $limit = ‪MathUtility::forceIntegerInRange($this->conf['special.']['limit'], 0, 100);
        // Start point
        $eLevel = $this->parent_cObj->getKey(
            isset($this->conf['special.']['entryLevel.'])
            ? $this->parent_cObj->stdWrap($this->conf['special.']['entryLevel'], $this->conf['special.']['entryLevel.'])
            : $this->conf['special.']['entryLevel'],
            $this->tmpl->rootLine
        );
        $startUid = (int)$this->tmpl->rootLine[$eLevel]['uid'];
        // Which field is for keywords
        $kfield = 'keywords';
        ‪if ($this->conf['special.']['keywordsField']) {
            [$kfield] = explode(' ', trim($this->conf['special.']['keywordsField']));
        }
        // If there are keywords and the startuid is present
        if ($kw && $startUid) {
            $bA = ‪MathUtility::forceIntegerInRange($this->conf['special.']['beginAtLevel'], 0, 100);
            $id_list = $this->parent_cObj->getTreeList(-1 * $startUid, $depth - 1 + $bA, $bA - 1);
            $kwArr = ‪GeneralUtility::trimExplode(',', $kw, true);
            $keyWordsWhereArr = [];
            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('pages');
            foreach ($kwArr as $word) {
                $keyWordsWhereArr[] = $queryBuilder->expr()->like(
                    $kfield,
                    $queryBuilder->createNamedParameter(
                        '%' . $queryBuilder->escapeLikeWildcards($word) . '%',
                        \PDO::PARAM_STR
                    )
                );
            }
            $queryBuilder
                ->select('*')
                ->from('pages')
                ->where(
                    $queryBuilder->expr()->in(
                        'uid',
                        ‪GeneralUtility::intExplode(',', $id_list, true)
                    ),
                    $queryBuilder->expr()->neq(
                        'uid',
                        $queryBuilder->createNamedParameter($specialValue, \PDO::PARAM_INT)
                    )
                );
 
            if (!empty($keyWordsWhereArr)) {
                $queryBuilder->andWhere($queryBuilder->expr()->orX(...$keyWordsWhereArr));
            }
 
            if (!empty($this->excludedDoktypes)) {
                $queryBuilder->andWhere(
                    $queryBuilder->expr()->notIn(
                        'pages.doktype',
                        $this->excludedDoktypes
                    )
                );
            }
 
            if (!$this->conf['includeNotInMenu']) {
                $queryBuilder->andWhere($queryBuilder->expr()->eq('pages.nav_hide', 0));
            }
 
            if ($this->conf['special.']['excludeNoSearchPages']) {
                $queryBuilder->andWhere($queryBuilder->expr()->eq('pages.no_search', 0));
            }
 
            if ($limit > 0) {
                $queryBuilder->setMaxResults($limit);
            }
 
            if ($sortingField) {
                $queryBuilder->orderBy($sortingField);
            } else {
                $queryBuilder->orderBy($sortField, 'desc');
            }
 
            ‪$result = $queryBuilder->execute();
            while ($row = ‪$result->fetch()) {
                $tsfe->sys_page->versionOL('pages', $row, true);
                if (is_array($row)) {
                    $menuItems[$row['uid']] = $this->sys_page->getPageOverlay($row);
                }
            }
        }
 
        return $menuItems;
    }
 
    protected function ‪prepareMenuItemsForRootlineMenu()
    {
        $menuItems = [];
        $range = isset($this->conf['special.']['range.'])
            ? $this->parent_cObj->stdWrap($this->conf['special.']['range'], $this->conf['special.']['range.'])
            : $this->conf['special.']['range'];
        $begin_end = explode('|', $range);
        $begin_end[0] = (int)$begin_end[0];
        if (!‪MathUtility::canBeInterpretedAsInteger($begin_end[1])) {
            $begin_end[1] = -1;
        }
        $beginKey = $this->parent_cObj->getKey($begin_end[0], $this->tmpl->rootLine);
        $endKey = $this->parent_cObj->getKey($begin_end[1], $this->tmpl->rootLine);
        if ($endKey < $beginKey) {
            $endKey = $beginKey;
        }
        $rl_MParray = [];
        foreach ($this->tmpl->rootLine as $k_rl => $v_rl) {
            // For overlaid mount points, set the variable right now:
            if ($v_rl['_MP_PARAM'] && $v_rl['_MOUNT_OL']) {
                $rl_MParray[] = $v_rl['_MP_PARAM'];
            }
            // Traverse rootline:
            if ($k_rl >= $beginKey && $k_rl <= $endKey) {
                $temp_key = $k_rl;
                $menuItems[$temp_key] = $this->sys_page->getPage($v_rl['uid']);
                if (!empty($menuItems[$temp_key])) {
                    // If there are no specific target for the page, put the level specific target on.
                    if (!$menuItems[$temp_key]['target']) {
                        $menuItems[$temp_key]['target'] = $this->conf['special.']['targets.'][$k_rl];
                        $menuItems[$temp_key]['_MP_PARAM'] = implode(',', $rl_MParray);
                    }
                } else {
                    unset($menuItems[$temp_key]);
                }
            }
            // For normal mount points, set the variable for next level.
            if ($v_rl['_MP_PARAM'] && !$v_rl['_MOUNT_OL']) {
                $rl_MParray[] = $v_rl['_MP_PARAM'];
            }
        }
        // Reverse order of elements (e.g. "1,2,3,4" gets "4,3,2,1"):
        if (isset($this->conf['special.']['reverseOrder']) && $this->conf['special.']['reverseOrder']) {
            $menuItems = array_reverse($menuItems);
        }
        return $menuItems;
    }
 
    protected function ‪prepareMenuItemsForBrowseMenu($specialValue, $sortingField, $additionalWhere)
    {
        $menuItems = [];
        [$specialValue] = ‪GeneralUtility::intExplode(',', $specialValue);
        if (!$specialValue) {
            $specialValue = $this->‪getTypoScriptFrontendController()->page['uid'];
        }
        // Will not work out of rootline
        if ($specialValue != $this->tmpl->rootLine[0]['uid']) {
            $recArr = [];
            // The page record of the 'value'.
            $value_rec = $this->sys_page->getPage($specialValue);
            // 'up' page cannot be outside rootline
            if ($value_rec['pid']) {
                // The page record of 'up'.
                $recArr['up'] = $this->sys_page->getPage($value_rec['pid']);
            }
            // If the 'up' item was NOT level 0 in rootline...
            if ($recArr['up']['pid'] && $value_rec['pid'] != $this->tmpl->rootLine[0]['uid']) {
                // The page record of "index".
                $recArr['index'] = $this->sys_page->getPage($recArr['up']['pid']);
            }
            // check if certain pages should be excluded
            $additionalWhere .= ($this->conf['includeNotInMenu'] ? '' : ' AND pages.nav_hide=0') . $this->‪getDoktypeExcludeWhere();
            if ($this->conf['special.']['excludeNoSearchPages']) {
                $additionalWhere .= ' AND pages.no_search=0';
            }
            // prev / next is found
            $prevnext_menu = $this->‪removeInaccessiblePages($this->sys_page->getMenu($value_rec['pid'], '*', $sortingField, $additionalWhere));
            $lastKey = 0;
            ‪$nextActive = 0;
            foreach ($prevnext_menu as $k_b => $v_b) {
                if (‪$nextActive) {
                    $recArr['next'] = $v_b;
                    ‪$nextActive = 0;
                }
                if ($v_b['uid'] == $specialValue) {
                    if ($lastKey) {
                        $recArr['prev'] = $prevnext_menu[$lastKey];
                    }
                    ‪$nextActive = 1;
                }
                $lastKey = $k_b;
            }
 
            $recArr['first'] = reset($prevnext_menu);
            $recArr['last'] = end($prevnext_menu);
            // prevsection / nextsection is found
            // You can only do this, if there is a valid page two levels up!
            if (!empty($recArr['index']['uid'])) {
                $prevnextsection_menu = $this->‪removeInaccessiblePages($this->sys_page->getMenu($recArr['index']['uid'], '*', $sortingField, $additionalWhere));
                $lastKey = 0;
                ‪$nextActive = 0;
                foreach ($prevnextsection_menu as $k_b => $v_b) {
                    if (‪$nextActive) {
                        $sectionRec_temp = $this->‪removeInaccessiblePages($this->sys_page->getMenu($v_b['uid'], '*', $sortingField, $additionalWhere));
                        if (!empty($sectionRec_temp)) {
                            $recArr['nextsection'] = reset($sectionRec_temp);
                            $recArr['nextsection_last'] = end($sectionRec_temp);
                            ‪$nextActive = 0;
                        }
                    }
                    if ($v_b['uid'] == $value_rec['pid']) {
                        if ($lastKey) {
                            $sectionRec_temp = $this->‪removeInaccessiblePages($this->sys_page->getMenu($prevnextsection_menu[$lastKey]['uid'], '*', $sortingField, $additionalWhere));
                            if (!empty($sectionRec_temp)) {
                                $recArr['prevsection'] = reset($sectionRec_temp);
                                $recArr['prevsection_last'] = end($sectionRec_temp);
                            }
                        }
                        ‪$nextActive = 1;
                    }
                    $lastKey = $k_b;
                }
            }
            if ($this->conf['special.']['items.']['prevnextToSection']) {
                if (!is_array($recArr['prev']) && is_array($recArr['prevsection_last'])) {
                    $recArr['prev'] = $recArr['prevsection_last'];
                }
                if (!is_array($recArr['next']) && is_array($recArr['nextsection'])) {
                    $recArr['next'] = $recArr['nextsection'];
                }
            }
            $items = explode('|', $this->conf['special.']['items']);
            $c = 0;
            foreach ($items as $k_b => $v_b) {
                $v_b = strtolower(trim($v_b));
                if ((int)$this->conf['special.'][$v_b . '.']['uid']) {
                    $recArr[$v_b] = $this->sys_page->getPage((int)$this->conf['special.'][$v_b . '.']['uid']);
                }
                if (is_array($recArr[$v_b])) {
                    $menuItems[$c] = $recArr[$v_b];
                    if ($this->conf['special.'][$v_b . '.']['target']) {
                        $menuItems[$c]['target'] = $this->conf['special.'][$v_b . '.']['target'];
                    }
                    $tmpSpecialFields = $this->conf['special.'][$v_b . '.']['fields.'];
                    if (is_array($tmpSpecialFields)) {
                        foreach ($tmpSpecialFields as $fk => $val) {
                            $menuItems[$c][$fk] = $val;
                        }
                    }
                    $c++;
                }
            }
        }
        return $menuItems;
    }
 
    public function ‪filterMenuPages(&$data, $banUidArray, $isSpacerPage)
    {
        $includePage = true;
        foreach (‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['cms/tslib/class.tslib_menu.php']['filterMenuPages'] ?? [] as $className) {
            $hookObject = GeneralUtility::makeInstance($className);
            if (!$hookObject instanceof AbstractMenuFilterPagesHookInterface) {
                throw new \UnexpectedValueException($className . ' must implement interface ' . AbstractMenuFilterPagesHookInterface::class, 1269877402);
            }
            $includePage = $includePage && $hookObject->processFilter($data, $banUidArray, $isSpacerPage, $this);
        }
        if (!$includePage) {
            return false;
        }
        if ($data['_SAFE']) {
            return true;
        }
        // If the spacer-function is not enabled, spacers will not enter the $menuArr
        if (!$this->mconf['SPC'] && $isSpacerPage) {
            return false;
        }
        // Page may not be a 'Backend User Section' or any other excluded doktype
        if (in_array((int)$data['doktype'], $this->excludedDoktypes, true)) {
            return false;
        }
        // PageID should not be banned
        if (in_array((int)$data['uid'], $banUidArray, true)) {
            return false;
        }
        // If the page is hide in menu, but the menu does not include them do not show the page
        if ($data['nav_hide'] && !$this->conf['includeNotInMenu']) {
            return false;
        }
        // Checking if a page should be shown in the menu depending on whether a translation exists or if the default language is disabled
        if (!$this->sys_page->isPageSuitableForLanguage($data, $this->getCurrentLanguageAspect())) {
            return false;
        }
        // Checking if "&L" should be modified so links to non-accessible pages will not happen.
        if ($this->‪getCurrentLanguageAspect()->getId() > 0 && $this->conf['protectLvar']) {
            if ($this->conf['protectLvar'] === 'all' || GeneralUtility::hideIfNotTranslated($data['l18n_cfg'])) {
                $olRec = $this->sys_page->getPageOverlay($data['uid'], $this->‪getCurrentLanguageAspect()->getId());
                if (empty($olRec)) {
                    // If no page translation record then page can NOT be accessed in
                    // the language pointed to by "&L" and therefore we protect the link by setting "&L=0"
                    $data['_ADD_GETVARS'] .= '&L=0';
                }
            }
        }
        return true;
    }
 
    protected function ‪processItemStates($splitCount)
    {
        // Prepare normal settings
        if (!is_array($this->mconf['NO.']) && $this->mconf['NO']) {
            // Setting a blank array if NO=1 and there are no properties.
            $this->mconf['NO.'] = [];
        }
        $typoScriptService = GeneralUtility::makeInstance(TypoScriptService::class);
        $NOconf = $typoScriptService->explodeConfigurationForOptionSplit((array)$this->mconf['NO.'], $splitCount);
 
        // Prepare custom states settings, overriding normal settings
        foreach (self::customItemStates as $state) {
            if (empty($this->mconf[$state])) {
                continue;
            }
            $customConfiguration = null;
            foreach ($NOconf as $key => $val) {
                if ($this->‪isItemState($state, $key)) {
                    // if this is the first element of type $state, we must generate the custom configuration.
                    if ($customConfiguration === null) {
                        $customConfiguration = $typoScriptService->explodeConfigurationForOptionSplit((array)$this->mconf[$state . '.'], $splitCount);
                    }
                    // Substitute normal with the custom (e.g. IFSUB)
                    if (isset($customConfiguration[$key])) {
                        $NOconf[$key] = $customConfiguration[$key];
                    }
                }
            }
        }
 
        return $NOconf;
    }
 
    protected function ‪link($key, $altTarget, $typeOverride)
    {
        $runtimeCache = $this->‪getRuntimeCache();
        $MP_var = $this->‪getMPvar($key);
        $cacheId = 'menu-generated-links-' . md5($key . $altTarget . $typeOverride . $MP_var . json_encode($this->menuArr[$key]));
        $runtimeCachedLink = $runtimeCache->get($cacheId);
        if ($runtimeCachedLink !== false) {
            return $runtimeCachedLink;
        }
 
        $tsfe = $this->‪getTypoScriptFrontendController();
 
        // If a user script returned the value overrideId in the menu array we use that as page id
        if (($this->mconf['overrideId'] ?? false) || ($this->menuArr[$key]['overrideId'] ?? false)) {
            $overrideId = (int)($this->mconf['overrideId'] ?: $this->menuArr[$key]['overrideId']);
            $overrideId = $overrideId > 0 ? $overrideId : null;
            // Clear MP parameters since ID was changed.
            $MP_params = '';
        } else {
            $overrideId = null;
            // Mount points:
            $MP_params = $MP_var ? '&MP=' . rawurlencode($MP_var) : '';
        }
        // Setting main target:
        if ($altTarget) {
            $mainTarget = $altTarget;
        } elseif ($this->mconf['target.']) {
            $mainTarget = $this->parent_cObj->stdWrap($this->mconf['target'], $this->mconf['target.']);
        } else {
            $mainTarget = $this->mconf['target'];
        }
        // Creating link:
        $addParams = ($this->mconf['addParams'] ?? '') . $MP_params;
        if (($this->mconf['collapse'] ?? false) && $this->‪isActive($this->menuArr[$key]['uid'], $this->‪getMPvar($key))) {
            $thePage = $this->sys_page->getPage($this->menuArr[$key]['pid']);
            $addParams .= $this->menuArr[$key]['_ADD_GETVARS'];
            $LD = $this->‪menuTypoLink($thePage, $mainTarget, $addParams, $typeOverride, $overrideId);
        } else {
            $addParams .= ($this->I['val']['additionalParams'] ?? '') . $this->menuArr[$key]['_ADD_GETVARS'];
            $LD = $this->‪menuTypoLink($this->menuArr[$key], $mainTarget, $addParams, $typeOverride, $overrideId);
        }
        // Override default target configuration if option is set
        if ($this->menuArr[$key]['target']) {
            $LD['target'] = $this->menuArr[$key]['target'];
        }
        // Override URL if using "External URL"
        if ((int)$this->menuArr[$key]['doktype'] === ‪PageRepository::DOKTYPE_LINK) {
            $externalUrl = (string)$this->sys_page->getExtURL($this->menuArr[$key]);
            // Create link using typolink (concerning spamProtectEmailAddresses) for email links
            $LD['totalURL'] = $this->parent_cObj->typoLink_URL(['parameter' => $externalUrl]);
            // Links to emails should not have any target
            if (stripos($externalUrl, 'mailto:') === 0) {
                $LD['target'] = '';
            // use external target for the URL
            } elseif (empty($LD['target']) && !empty($tsfe->extTarget)) {
                $LD['target'] = $tsfe->extTarget;
            }
        }
 
        // Override url if current page is a shortcut
        $shortcut = null;
        if ((int)$this->menuArr[$key]['doktype'] === ‪PageRepository::DOKTYPE_SHORTCUT && (int)$this->menuArr[$key]['shortcut_mode'] !== ‪PageRepository::SHORTCUT_MODE_RANDOM_SUBPAGE) {
            $menuItem = $this->menuArr[$key];
            try {
                $shortcut = $tsfe->sys_page->getPageShortcut(
                    $menuItem['shortcut'],
                    $menuItem['shortcut_mode'],
                    $menuItem['uid'],
                    20,
                    [],
                    true
                );
                if (isset($menuItem['_PAGES_OVERLAY_LANGUAGE'])) {
                    $shortcut = $tsfe->sys_page->getPageOverlay($shortcut, $menuItem['_PAGES_OVERLAY_LANGUAGE']);
                }
            } catch (\Exception $ex) {
            }
            if (!is_array($shortcut)) {
                $runtimeCache->set($cacheId, []);
                return [];
            }
            // Only setting url, not target
            $LD['totalURL'] = $this->parent_cObj->typoLink_URL([
                'parameter' => $shortcut['uid'],
                'language' => $shortcut['_PAGES_OVERLAY_REQUESTEDLANGUAGE'] ?? 'current',
                'additionalParams' => $addParams . $this->I['val']['additionalParams'] . $menuItem['_ADD_GETVARS'],
                'linkAccessRestrictedPages' => !empty($this->mconf['showAccessRestrictedPages'])
            ]);
        }
        if ($shortcut) {
            $pageData = $shortcut;
            $pageData['_SHORTCUT_PAGE_UID'] = $this->menuArr[$key]['uid'];
        } else {
            $pageData = $this->menuArr[$key];
        }
        // Manipulation in case of access restricted pages:
        $this->‪changeLinksForAccessRestrictedPages($LD, $pageData, $mainTarget, $typeOverride);
        // Overriding URL / Target if set to do so:
        if ($this->menuArr[$key]['_OVERRIDE_HREF'] ?? false) {
            $LD['totalURL'] = $this->menuArr[$key]['_OVERRIDE_HREF'];
            if ($this->menuArr[$key]['_OVERRIDE_TARGET']) {
                $LD['target'] = $this->menuArr[$key]['_OVERRIDE_TARGET'];
            }
        }
        // OnClick open in windows.
        $onClick = '';
        if ($this->mconf['JSWindow'] ?? false) {
            ‪$conf = $this->mconf['JSWindow.'];
            $url = $LD['totalURL'];
            $LD['totalURL'] = '#';
            $onClick = 'openPic('
                . GeneralUtility::quoteJSvalue($tsfe->baseUrlWrap($url)) . ','
                . '\'' . (‪$conf['newWindow'] ? md5($url) : 'theNewPage') . '\','
                . GeneralUtility::quoteJSvalue(‪$conf['params']) . '); return false;';
            $tsfe->setJS('openPic');
        }
        // look for type and popup
        // following settings are valid in field target:
        // 230                              will add type=230 to the link
        // 230 500x600                      will add type=230 to the link and open in popup window with 500x600 pixels
        // 230 _blank                       will add type=230 to the link and open with target "_blank"
        // 230x450:resizable=0,location=1   will open in popup window with 500x600 pixels with settings "resizable=0,location=1"
        $matches = [];
        $targetIsType = $LD['target'] && ‪MathUtility::canBeInterpretedAsInteger($LD['target']) ? (int)$LD['target'] : false;
        if (preg_match('/([0-9]+[\\s])?(([0-9]+)x([0-9]+))?(:.+)?/s', $LD['target'], $matches) || $targetIsType) {
            // has type?
            if ((int)($matches[1] ?? 0) || $targetIsType) {
                $LD['totalURL'] .= (strpos($LD['totalURL'], '?') === false ? '?' : '&') . 'type=' . ($targetIsType ?: (int)$matches[1]);
                $LD['target'] = $targetIsType ? '' : trim(substr($LD['target'], strlen($matches[1]) + 1));
            }
            // Open in popup window?
            if (($matches[3] ?? false) && ($matches[4] ?? false)) {
                $target = $LD['target'] ?? 'FEopenLink';
                $JSparamWH = 'width=' . $matches[3] . ',height=' . $matches[4] . ($matches[5] ? ',' . substr($matches[5], 1) : '');
                $onClick = 'openPic('
                    . GeneralUtility::quoteJSvalue($tsfe->baseUrlWrap($LD['totalURL']))
                    . ',' . GeneralUtility::quoteJSvalue($target) . ',' . GeneralUtility::quoteJSvalue($JSparamWH) . ');vHWin.focus();return false;';
                $tsfe->setJS('openPic');
                $LD['target'] = '';
            }
        }
        // out:
        $list = [];
        // Added this check: What it does is to enter the baseUrl (if set, which it should for "realurl" based sites)
        // as URL if the calculated value is empty. The problem is that no link is generated with a blank URL
        // and blank URLs might appear when the realurl encoding is used and a link to the frontpage is generated.
        $list['HREF'] = (string)$LD['totalURL'] !== '' ? $LD['totalURL'] : $tsfe->baseUrl;
        $list['TARGET'] = $LD['target'];
        $list['onClick'] = $onClick;
        $runtimeCache->set($cacheId, $list);
        return $list;
    }
 
    protected function ‪determineOriginalShortcutPage(array $page)
    {
        // Check if modification is required
        if (
            $this->‪getCurrentLanguageAspect()->getId() > 0
            && empty($page['shortcut'])
            && !empty($page['uid'])
            && !empty($page['_PAGES_OVERLAY'])
            && !empty($page['_PAGES_OVERLAY_UID'])
        ) {
            // Using raw record since the record was overlaid and is correct already:
            $originalPage = $this->sys_page->getRawRecord('pages', $page['uid']);
 
            if ($originalPage['shortcut_mode'] === $page['shortcut_mode'] && !empty($originalPage['shortcut'])) {
                $page['shortcut'] = $originalPage['shortcut'];
            }
        }
 
        return $page;
    }
 
    protected function ‪changeLinksForAccessRestrictedPages(&$LD, $page, $mainTarget, $typeOverride)
    {
        // If access restricted pages should be shown in menus, change the link of such pages to link to a redirection page:
        if (($this->mconf['showAccessRestrictedPages'] ?? false) && $this->mconf['showAccessRestrictedPages'] !== 'NONE' && !$this->‪getTypoScriptFrontendController()->checkPageGroupAccess($page)) {
            $thePage = $this->sys_page->getPage($this->mconf['showAccessRestrictedPages']);
            $addParams = str_replace(
                [
                    '###RETURN_URL###',
                    '###PAGE_ID###'
                ],
                [
                    rawurlencode($LD['totalURL']),
                    $page['_SHORTCUT_PAGE_UID'] ?? $page['uid']
                ],
                $this->mconf['showAccessRestrictedPages.']['addParams']
            );
            $LD = $this->‪menuTypoLink($thePage, $mainTarget, $addParams, $typeOverride);
        }
    }
 
    protected function ‪subMenu($uid, $objSuffix)
    {
        // Setting alternative menu item array if _SUB_MENU has been defined in the current ->menuArr
        $altArray = '';
        if (is_array($this->menuArr[$this->I['key']]['_SUB_MENU'] ?? null) && !empty($this->menuArr[$this->I['key']]['_SUB_MENU'])) {
            $altArray = $this->menuArr[$this->I['key']]['_SUB_MENU'];
        }
        // Make submenu if the page is the next active
        $menuType = $this->conf[($this->menuNumber + 1) . $objSuffix] ?? '';
        // stdWrap for expAll
        if (isset($this->mconf['expAll.'])) {
            $this->mconf['expAll'] = $this->parent_cObj->stdWrap($this->mconf['expAll'], $this->mconf['expAll.']);
        }
        if ((($this->mconf['expAll'] ?? false) || $this->‪isNext($uid, $this->‪getMPvar($this->I['key'])) || is_array($altArray)) && !($this->mconf['sectionIndex'] ?? false)) {
            try {
                $menuObjectFactory = GeneralUtility::makeInstance(MenuContentObjectFactory::class);
                $submenu = $menuObjectFactory->getMenuObjectByType($menuType);
                $submenu->entryLevel = $this->entryLevel + 1;
                $submenu->rL_uidRegister = ‪$this->rL_uidRegister;
                $submenu->MP_array = ‪$this->MP_array;
                if ($this->menuArr[$this->I['key']]['_MP_PARAM']) {
                    $submenu->MP_array[] = $this->menuArr[$this->I['key']]['_MP_PARAM'];
                }
                // Especially scripts that build the submenu needs the parent data
                $submenu->parent_cObj = ‪$this->parent_cObj;
                $submenu->setParentMenu($this->menuArr, $this->I['key']);
                // Setting alternativeMenuTempArray (will be effective only if an array)
                if (is_array($altArray)) {
                    $submenu->alternativeMenuTempArray = $altArray;
                }
                if ($submenu->start($this->tmpl, $this->sys_page, $uid, $this->conf, $this->menuNumber + 1, $objSuffix)) {
                    $submenu->makeMenu();
                    // Memorize the current menu item count
                    $tsfe = $this->‪getTypoScriptFrontendController();
                    $tempCountMenuObj = $tsfe->register['count_MENUOBJ'];
                    // Reset the menu item count for the submenu
                    $tsfe->register['count_MENUOBJ'] = 0;
                    $content = $submenu->writeMenu();
                    // Restore the item count now that the submenu has been handled
                    $tsfe->register['count_MENUOBJ'] = $tempCountMenuObj;
                    $tsfe->register['count_menuItems'] = count($this->menuArr);
                    return $content;
                }
            } catch (‪NoSuchMenuTypeException $e) {
            }
        }
        return '';
    }
 
    protected function ‪isNext($uid, $MPvar)
    {
        // Check for always active PIDs:
        if (in_array((int)$uid, $this->alwaysActivePIDlist, true)) {
            return true;
        }
        $testUid = $uid . ($MPvar ? ':' . $MPvar : '');
        if ($uid && $testUid == $this->nextActive) {
            return true;
        }
        return false;
    }
 
    protected function ‪isActive($uid, $MPvar)
    {
        // Check for always active PIDs:
        if (in_array((int)$uid, $this->alwaysActivePIDlist, true)) {
            return true;
        }
        $testUid = $uid . ($MPvar ? ':' . $MPvar : '');
        if ($uid && in_array('ITEM:' . $testUid, $this->rL_uidRegister, true)) {
            return true;
        }
        return false;
    }
 
    protected function ‪isCurrent($uid, $MPvar)
    {
        $testUid = $uid . ($MPvar ? ':' . $MPvar : '');
        return $uid && end($this->rL_uidRegister) === 'ITEM:' . $testUid;
    }
 
    protected function ‪isSubMenu($uid)
    {
        $cacheId = 'menucontentobject-is-submenu-decision-' . $uid . '-' . (int)($this->conf['includeNotInMenu'] ?? 0);
        $runtimeCache = $this->‪getRuntimeCache();
        $cachedDecision = $runtimeCache->get($cacheId);
        if (isset($cachedDecision['result'])) {
            return $cachedDecision['result'];
        }
        // Looking for a mount-pid for this UID since if that
        // exists we should look for a subpages THERE and not in the input $uid;
        $mount_info = $this->sys_page->getMountPointInfo($uid);
        if (is_array($mount_info)) {
            $uid = $mount_info['mount_pid'];
        }
        $recs = $this->sys_page->getMenu($uid, 'uid,pid,doktype,mount_pid,mount_pid_ol,nav_hide,shortcut,shortcut_mode,l18n_cfg');
        $hasSubPages = false;
        $bannedUids = $this->‪getBannedUids();
        $languageId = $this->‪getCurrentLanguageAspect()->getId();
        foreach ($recs as $theRec) {
            // no valid subpage if the document type is excluded from the menu
            if (in_array((int)($theRec['doktype'] ?? 0), $this->excludedDoktypes, true)) {
                continue;
            }
            // No valid subpage if the page is hidden inside menus and
            // it wasn't forced to show such entries
            if (isset($theRec['nav_hide']) && $theRec['nav_hide']
                && (!isset($this->conf['includeNotInMenu']) || !$this->conf['includeNotInMenu'])
            ) {
                continue;
            }
            // No valid subpage if the default language should be shown and the page settings
            // are excluding the visibility of the default language
            if (!$languageId && GeneralUtility::hideIfDefaultLanguage($theRec['l18n_cfg'] ?? 0)) {
                continue;
            }
            // No valid subpage if the alternative language should be shown and the page settings
            // are requiring a valid overlay but it doesn't exists
            $hideIfNotTranslated = GeneralUtility::hideIfNotTranslated($theRec['l18n_cfg'] ?? null);
            if ($languageId && $hideIfNotTranslated && !$theRec['_PAGES_OVERLAY']) {
                continue;
            }
            // No valid subpage if the subpage is banned by excludeUidList
            if (in_array((int)$theRec['uid'], $bannedUids, true)) {
                continue;
            }
            $hasSubPages = true;
            break;
        }
        $runtimeCache->set($cacheId, ['result' => $hasSubPages]);
        return $hasSubPages;
    }
 
    protected function ‪isItemState($kind, $key)
    {
        $natVal = false;
        // If any value is set for ITEM_STATE the normal evaluation is discarded
        if ($this->menuArr[$key]['ITEM_STATE'] ?? false) {
            if ((string)$this->menuArr[$key]['ITEM_STATE'] === (string)$kind) {
                $natVal = true;
            }
        } else {
            switch ($kind) {
                case 'SPC':
                    $natVal = (bool)$this->menuArr[$key]['isSpacer'];
                    break;
                case 'IFSUB':
                    $natVal = $this->‪isSubMenu($this->menuArr[$key]['uid']);
                    break;
                case 'ACT':
                    $natVal = $this->‪isActive($this->menuArr[$key]['uid'], $this->‪getMPvar($key));
                    break;
                case 'ACTIFSUB':
                    $natVal = $this->‪isActive($this->menuArr[$key]['uid'], $this->‪getMPvar($key)) && $this->‪isSubMenu($this->menuArr[$key]['uid']);
                    break;
                case 'CUR':
                    $natVal = $this->‪isCurrent($this->menuArr[$key]['uid'], $this->‪getMPvar($key));
                    break;
                case 'CURIFSUB':
                    $natVal = $this->‪isCurrent($this->menuArr[$key]['uid'], $this->‪getMPvar($key)) && $this->‪isSubMenu($this->menuArr[$key]['uid']);
                    break;
                case 'USR':
                    $natVal = (bool)$this->menuArr[$key]['fe_group'];
                    break;
            }
        }
        return $natVal;
    }
 
    protected function ‪accessKey($title)
    {
        $tsfe = $this->‪getTypoScriptFrontendController();
        // The global array ACCESSKEY is used to globally control if letters are already used!!
        $result = [];
        $title = trim(strip_tags($title));
        $titleLen = strlen($title);
        for ($a = 0; $a < $titleLen; $a++) {
            $key = strtoupper(substr($title, $a, 1));
            if (preg_match('/[A-Z]/', $key) && !isset($tsfe->accessKey[$key])) {
                $tsfe->accessKey[$key] = true;
                ‪$result['code'] = ' accesskey="' . $key . '"';
                ‪$result['alt'] = ' (ALT+' . $key . ')';
                ‪$result['key'] = $key;
                break;
            }
        }
        return ‪$result;
    }
 
    protected function ‪userProcess($mConfKey, $passVar)
    {
        if ($this->mconf[$mConfKey]) {
            $funcConf = (array)($this->mconf[$mConfKey . '.'] ?? []);
            $funcConf['parentObj'] = $this;
            $passVar = $this->parent_cObj->callUserFunction($this->mconf[$mConfKey], $funcConf, $passVar);
        }
        return $passVar;
    }
 
    protected function ‪setATagParts()
    {
        $params = trim($this->I['val']['ATagParams']) . $this->I['accessKey']['code'];
        $params = $params !== '' ? ' ' . $params : '';
        $this->I['A1'] = '<a ' . GeneralUtility::implodeAttributes($this->I['linkHREF'], true) . $params . '>';
        $this->I['A2'] = '</a>';
    }
 
    protected function ‪getPageTitle($title, $nav_title)
    {
        return trim($nav_title) !== '' ? $nav_title : $title;
    }
 
    protected function ‪getMPvar($key)
    {
        if (‪$GLOBALS['TYPO3_CONF_VARS']['FE']['enable_mount_pids']) {
            $localMP_array = ‪$this->MP_array;
            // NOTICE: "_MP_PARAM" is allowed to be a commalist of PID pairs!
            if ($this->menuArr[$key]['_MP_PARAM'] ?? false) {
                $localMP_array[] = $this->menuArr[$key]['_MP_PARAM'];
            }
            return !empty($localMP_array) ? implode(',', $localMP_array) : '';
        }
        return '';
    }
 
    protected function ‪getDoktypeExcludeWhere()
    {
        return !empty($this->excludedDoktypes) ? ' AND pages.doktype NOT IN (' . implode(',', $this->excludedDoktypes) . ')' : '';
    }
 
    protected function ‪getBannedUids()
    {
        $excludeUidList = isset($this->conf['excludeUidList.'])
            ? $this->parent_cObj->stdWrap($this->conf['excludeUidList'], $this->conf['excludeUidList.'])
            : $this->conf['excludeUidList'];
 
        if (!trim($excludeUidList)) {
            return [];
        }
 
        $banUidList = str_replace('current', $this->‪getTypoScriptFrontendController()->page['uid'] ?? null, $excludeUidList);
        return ‪GeneralUtility::intExplode(',', $banUidList);
    }
 
    protected function ‪menuTypoLink($page, $oTarget, $addParams, $typeOverride, ?int $overridePageId = null)
    {
        ‪$conf = [
            'parameter' => $overridePageId ?? $page['uid']
        ];
        if (‪MathUtility::canBeInterpretedAsInteger($typeOverride)) {
            ‪$conf['parameter'] .= ',' . (int)$typeOverride;
        }
        if ($addParams) {
            ‪$conf['additionalParams'] = $addParams;
        }
 
        // Ensure that the typolink gets an info which language was actually requested. The $page record could be the record
        // from page translation language=1 as fallback but page translation language=2 was requested. Search for
        // "_PAGES_OVERLAY_REQUESTEDLANGUAGE" for more details
        if (isset($page['_PAGES_OVERLAY_REQUESTEDLANGUAGE'])) {
            ‪$conf['language'] = $page['_PAGES_OVERLAY_REQUESTEDLANGUAGE'];
        }
        if ($oTarget) {
            ‪$conf['target'] = $oTarget;
        }
        if ($page['sectionIndex_uid'] ?? false) {
            ‪$conf['section'] = $page['sectionIndex_uid'];
        }
        ‪$conf['linkAccessRestrictedPages'] = !empty($this->mconf['showAccessRestrictedPages']);
        $this->parent_cObj->typoLink('|', ‪$conf);
        $LD = $this->parent_cObj->lastTypoLinkLD;
        $LD['totalURL'] = $this->parent_cObj->lastTypoLinkUrl;
        return $LD;
    }
 
    protected function ‪sectionIndex($altSortField, $pid = null)
    {
        $pid = (int)($pid ?: $this->id);
        $basePageRow = $this->sys_page->getPage($pid);
        if (!is_array($basePageRow)) {
            return [];
        }
        $tsfe = $this->‪getTypoScriptFrontendController();
        $configuration = $this->mconf['sectionIndex.'] ?? [];
        $useColPos = 0;
        if (trim($configuration['useColPos'] ?? '') !== ''
            || (isset($configuration['useColPos.']) && is_array($configuration['useColPos.']))
        ) {
            $useColPos = $tsfe->cObj->stdWrap($configuration['useColPos'] ?? '', $configuration['useColPos.'] ?? []);
            $useColPos = (int)$useColPos;
        }
        $selectSetup = [
            'pidInList' => $pid,
            'orderBy' => $altSortField,
            'languageField' => 'sys_language_uid',
            'where' => ''
        ];
 
        if ($useColPos >= 0) {
            $expressionBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                ->getConnectionForTable('tt_content')
                ->getExpressionBuilder();
            $selectSetup['where'] = $expressionBuilder->eq('colPos', $useColPos);
        }
 
        if ($basePageRow['content_from_pid'] ?? false) {
            // If the page is configured to show content from a referenced page the sectionIndex contains only contents of
            // the referenced page
            $selectSetup['pidInList'] = $basePageRow['content_from_pid'];
        }
        $statement = $this->parent_cObj->exec_getQuery('tt_content', $selectSetup);
        if (!$statement) {
            $message = 'SectionIndex: Query to fetch the content elements failed!';
            throw new \UnexpectedValueException($message, 1337334849);
        }
        ‪$result = [];
        while ($row = $statement->fetch()) {
            $this->sys_page->versionOL('tt_content', $row);
            if ($this->‪getCurrentLanguageAspect()->doOverlays() && $basePageRow['_PAGES_OVERLAY_LANGUAGE']) {
                $row = $this->sys_page->getRecordOverlay(
                    'tt_content',
                    $row,
                    $basePageRow['_PAGES_OVERLAY_LANGUAGE'],
                    $this->‪getCurrentLanguageAspect()->getOverlayType() === ‪LanguageAspect::OVERLAYS_MIXED ? '1' : 'hideNonTranslated'
                );
            }
            if ($this->mconf['sectionIndex.']['type'] !== 'all') {
                $doIncludeInSectionIndex = $row['sectionIndex'] >= 1;
                $doHeaderCheck = $this->mconf['sectionIndex.']['type'] === 'header';
                $isValidHeader = ((int)$row['header_layout'] !== 100 || !empty($this->mconf['sectionIndex.']['includeHiddenHeaders'])) && trim($row['header']) !== '';
                if (!$doIncludeInSectionIndex || $doHeaderCheck && !$isValidHeader) {
                    continue;
                }
            }
            if (is_array($row)) {
                $uid = $row['uid'] ?? null;
                ‪$result[$uid] = $basePageRow;
                ‪$result[$uid]['title'] = $row['header'];
                ‪$result[$uid]['nav_title'] = $row['header'];
                // Prevent false exclusion in filterMenuPages, thus: Always show tt_content records
                ‪$result[$uid]['nav_hide'] = 0;
                ‪$result[$uid]['subtitle'] = $row['subheader'] ?? '';
                ‪$result[$uid]['starttime'] = $row['starttime'] ?? '';
                ‪$result[$uid]['endtime'] = $row['endtime'] ?? '';
                ‪$result[$uid]['fe_group'] = $row['fe_group'] ?? '';
                ‪$result[$uid]['media'] = $row['media'] ?? '';
                ‪$result[$uid]['header_layout'] = $row['header_layout'] ?? '';
                ‪$result[$uid]['bodytext'] = $row['bodytext'] ?? '';
                ‪$result[$uid]['image'] = $row['image'] ?? '';
                ‪$result[$uid]['sectionIndex_uid'] = $uid;
            }
        }
 
        return ‪$result;
    }
 
    public function ‪getSysPage()
    {
        return ‪$this->sys_page;
    }
 
    public function ‪getParentContentObject()
    {
        return ‪$this->parent_cObj;
    }
 
    protected function ‪getTypoScriptFrontendController()
    {
        return ‪$GLOBALS['TSFE'];
    }
 
    protected function ‪getCurrentLanguageAspect(): ‪LanguageAspect
    {
        return GeneralUtility::makeInstance(Context::class)->getAspect('language');
    }
 
    protected function ‪getTimeTracker()
    {
        return GeneralUtility::makeInstance(TimeTracker::class);
    }
 
    protected function ‪getCache()
    {
        return GeneralUtility::makeInstance(CacheManager::class)->getCache('hash');
    }
 
    protected function ‪getRuntimeCache()
    {
        return GeneralUtility::makeInstance(CacheManager::class)->getCache('runtime');
    }
 
    protected function ‪getCurrentSite(): ‪SiteInterface
    {
        try {
            return GeneralUtility::makeInstance(SiteFinder::class)
                ->getSiteByPageId((int)$this->‪getTypoScriptFrontendController()->id);
        } catch (‪SiteNotFoundException $e) {
            return new ‪NullSite();
        }
    }
 
    public function ‪setParentMenu(array ‪$menuArr, $menuItemKey)
    {
        // check if menuArr is a valid array and that menuItemKey matches an existing menuItem in menuArr
        if (is_array(‪$menuArr)
            && (is_int($menuItemKey) && $menuItemKey >= 0 && isset(‪$menuArr[$menuItemKey]))
        ) {
            $this->parentMenuArr = ‪$menuArr;
            $this->parentMenuArrItemKey = $menuItemKey;
        }
    }
 
    protected function ‪hasParentMenuArr()
    {
        return
            $this->menuNumber > 1
            && is_array($this->parentMenuArr)
            && !empty($this->parentMenuArr)
        ;
    }
 
    protected function ‪hasParentMenuItemKey()
    {
        return null !== ‪$this->parentMenuArrItemKey;
    }
 
    protected function ‪hasParentMenuItem()
    {
        return
            $this->‪hasParentMenuArr()
            && $this->‪hasParentMenuItemKey()
            && isset($this->‪getParentMenuArr()[$this->parentMenuArrItemKey])
        ;
    }
 
    public function ‪getParentMenuArr()
    {
        return $this->‪hasParentMenuArr() ? $this->parentMenuArr : [];
    }
 
    public function ‪getParentMenuItem()
    {
        // check if we have a parentMenuItem and if it is an array
        if ($this->‪hasParentMenuItem()
            && is_array($this->‪getParentMenuArr()[$this->parentMenuArrItemKey])
        ) {
            return $this->‪getParentMenuArr()[‪$this->parentMenuArrItemKey];
        }
 
        return null;
    }
}