@capsitech/react-utilities 0.1.10 → 0.1.11

package/lib/Utilities/LoadScripts.js

@@ -0,0 +1,51 @@
+export const LoadScript = (src, opts, callback) => {
+    var head = document.head || document.getElementsByTagName('head')[0];
+    var script = document.createElement('script');
+    if (typeof opts === 'function') {
+        callback = opts;
+        opts = {};
+    }
+    opts = opts || {};
+    callback = callback || function () { };
+    script.type = opts.type || 'text/javascript';
+    script.charset = opts.charset || 'utf8';
+    script.async = 'async' in opts ? !!opts.async : true;
+    script.src = src;
+    if (opts.attrs) {
+        for (var attr in opts.attrs) {
+            script.setAttribute(attr, opts.attrs[attr]);
+        }
+    }
+    if (opts.text) {
+        script.text = '' + opts.text;
+    }
+    var onend = 'onload' in script ? stdOnEnd : ieOnEnd;
+    onend(script, callback);
+    // some good legacy browsers (firefox) fail the 'in' detection above
+    // so as a fallback we always set onload
+    // old IE will ignore this and new IE will set onload
+    if (!script.onload) {
+        stdOnEnd(script, callback);
+    }
+    head.appendChild(script);
+};
+function stdOnEnd(script, callback) {
+    script.onload = function () {
+        this.onerror = this.onload = null;
+        callback(null, script);
+    };
+    script.onerror = function () {
+        // this.onload = null here is necessary
+        // because even IE9 works not like others
+        this.onerror = this.onload = null;
+        callback(new Error('Failed to load ' + this.src), script);
+    };
+}
+function ieOnEnd(script, callback) {
+    script.onreadystatechange = function () {
+        if (this.readyState !== 'complete' && this.readyState !== 'loaded')
+            return;
+        this.onreadystatechange = null;
+        callback(null, script); // there is no way to catch loading errors in IE8
+    };
+}

package/lib/Utilities/MTDFraudPrevention.js

@@ -0,0 +1,157 @@
+import { getScreenColourDepth, getScreenHeight, getScreenScalingFactor, getScreenWidth, getTimezone, getWindowHeight, getWindowWidth } from './BrowserInfo';
+/**
+ * Enum object of keys for each header in the Map returned by getFraudPreventionHeaders().headers
+ */
+export const fraudPreventionHeadersEnum = {
+    TIMEZONE: 'Gov-Client-Timezone',
+    SCREENS_DETAILS: 'Gov-Client-Screens',
+    WINDOW_SIZE: 'Gov-Client-Window-Size',
+    //BROWSER_PLUGINS: 'Gov-Client-Browser-Plugins',
+    //BROWSER_DONOTTRACK: 'Gov-Client-Browser-Do-Not-Track',
+    //DEVICE_LOCAL_IPS: 'Gov-Client-Local-IPs',
+    //DEVICE_LOCAL_IPS_TIMESTAMP: 'Gov-Client-Local-IPs-Timestamp',
+    //DEVICE_ID: 'Gov-Client-Device-ID',
+    //BROWSER_USER_AGENT: 'Gov-Client-Browser-JS-User-Agent',
+};
+const getScreenData = () => {
+    const screenDetails = `width=${getScreenWidth()}&height=${getScreenHeight()}&scaling-factor=${getScreenScalingFactor()}&colour-depth=${getScreenColourDepth()}`;
+    return encodeURI(screenDetails);
+};
+export const getScreenDetails = () => {
+    return {
+        width: getScreenWidth(),
+        height: getScreenHeight(),
+        colorDepth: getScreenColourDepth(),
+        scalingFactor: getScreenScalingFactor(),
+    };
+};
+const getWindowSize = () => {
+    const windowSize = `width=${getWindowWidth()}&height=${getWindowHeight()}`;
+    return encodeURI(windowSize);
+};
+export const windowDetails = () => {
+    return {
+        width: getWindowWidth(),
+        height: getWindowHeight(),
+    };
+};
+/**
+ * Returns Map of HMRC Fraud prevention headers.
+ * @returns {Promise<IHeaderValues>} with two fields headers and errors - The headers are a Map object and the errors are an array. If there are no errors, the array is empty
+ */
+export const getFraudPreventionHeaders = async () => {
+    const headers = {};
+    const errors = [];
+    const headerFunctions = [
+        { header: fraudPreventionHeadersEnum.TIMEZONE, callback: getTimezone },
+        {
+            header: fraudPreventionHeadersEnum.SCREENS_DETAILS,
+            callback: getScreenData,
+        },
+        { header: fraudPreventionHeadersEnum.WINDOW_SIZE, callback: getWindowSize },
+        // {
+        //   header: fraudPreventionHeadersEnum.BROWSER_PLUGINS,
+        //   callback: () => encodeURI(getBrowserPluginsAsString()),
+        // },
+        // {
+        //   header: fraudPreventionHeadersEnum.BROWSER_DONOTTRACK,
+        //   callback: getBrowserDoNotTrackStatus,
+        // },
+        //{ header: fraudPreventionHeadersEnum.DEVICE_ID, callback: generateClientDeviceID},
+        //{ header: fraudPreventionHeadersEnum.BROWSER_USER_AGENT, callback: getUserAgent },
+    ];
+    for (let i = 0; i < headerFunctions.length; i++) {
+        try {
+            const { header, callback } = headerFunctions[i];
+            headers[header] = callback();
+        }
+        catch (error) {
+            errors.push({ header: headerFunctions[i], error });
+        }
+    }
+    // try {
+    //   const ipAddress = await getDeviceLocalIPAsString();
+    //   headers[fraudPreventionHeadersEnum.DEVICE_LOCAL_IPS] = encodeURI(ipAddress.deviceIpString);
+    //   headers[fraudPreventionHeadersEnum.DEVICE_LOCAL_IPS_TIMESTAMP] = ipAddress.deviceIpTimeStamp;
+    // } catch (error) {
+    //   errors.push({ header: 'IPs', error });
+    // }
+    return { headers, errors };
+};
+// /**
+//  * Returns "Gov-Client-Browser-JS-User-Agent" header.
+//  * @returns {IHeaderValue} which has headerValue key having the value of the header or error key if there is an error
+//  */
+// export const getGovClientBrowserJSUserAgentHeader = (): IHeaderValue => {
+//   try {
+//     return { headerValue: getUserAgent() };
+//   } catch (error) {
+//     return { error };
+//   }
+// };
+// /**
+//  * Returns the value for Gov-Client-Browser-Plugins HMRC Fraud prevention header.
+//  */
+// export const getGovClientBrowserPluginsHeader = (): IHeaderValue => {
+//   try {
+//     return { headerValue: encodeURI(getBrowserPluginsAsString()) };
+//   } catch (error) {
+//     return { error };
+//   }
+// };
+// /**
+//  * Returns the value for Gov-Client-Browser-Do-Not-Track HMRC Fraud prevention header.
+//  */
+// export const getGovClientBrowserDoNotTrackHeader = (): IHeaderValue => {
+//   try {
+//     return { headerValue: getBrowserDoNotTrackStatus() };
+//   } catch (error) {
+//     return { error };
+//   }
+// };
+// /**
+//  * Returns the value for Gov-Client-Timezone HMRC Fraud prevention header.
+//  * @returns {IHeaderValue} with headerValue field or error field in case of an exception
+//  */
+// export const getGovClientTimezoneHeader = (): IHeaderValue => {
+//   try {
+//     return { headerValue: getTimezone() };
+//   } catch (error) {
+//     return { error };
+//   }
+// };
+// /**
+//  * Returns Gov-Client-Local-IPs header value
+//  * @returns {Promise<IHeaderValue>} which has header key having the value of the header or error key if there is an error
+//  */
+// export const getGovClientLocalIPsHeader = async (): Promise<IHeaderValue> => {
+//   try {
+//     const ipAddress = await getDeviceLocalIPAsString();
+//     return {
+//       headerValue: encodeURI(ipAddress.deviceIpString),
+//     };
+//   } catch (error) {
+//     return { error };
+//   }
+// };
+// /**
+//  * Returns the value for Gov-Client-Window-Size HMRC Fraud prevention header.
+//  */
+// export const getGovClientWindowSizeHeader = () => {
+//   try {
+//     return { headerValue: getWindowSize() };
+//   } catch (error) {
+//     return { error };
+//   }
+// };
+// /**
+//  * Returns the value for Gov-Client-Screens HMRC Fraud prevention header.
+//  * @returns {object} with headerValue key having the value of the header or error key if there is an error
+//  */
+// export const getGovClientScreensHeader = () => {
+//   try {
+//     return { headerValue: getScreenData() };
+//   } catch (error) {
+//     return { error };
+//   }
+// };

package/lib/Utilities/Nationalities.js

@@ -0,0 +1,245 @@
+export const AllNationalities = [
+    'Afghan',
+    'Albanian',
+    'Algerian',
+    'American Samoan',
+    'Andorran',
+    'Angolan',
+    'Anguillan',
+    'Antarctic',
+    'Antiguan or Barbudan',
+    'Argentine',
+    'Armenian',
+    'Aruban',
+    'Australian',
+    'Austrian',
+    'Azerbaijani',
+    'Bahamian',
+    'Bahraini',
+    'Bangladeshi',
+    'Barbadian',
+    'Belarusian',
+    'Belgian',
+    'Belizean',
+    'Bermudian',
+    'Bhutanese',
+    'Bolivian',
+    'Bosnian or Herzegovinian',
+    'Botswanan',
+    'Brazilian',
+    'British Indian Ocean Territory',
+    'British Virgin Islander',
+    'Bruneian',
+    'Bulgarian',
+    'Burkinabe',
+    'Burundian',
+    'Cambodian',
+    'Cameroonian',
+    'Canadian',
+    'Cape Verdean',
+    'Caymanian',
+    'Central African',
+    'Beninese',
+    'Chadian',
+    'Chilean',
+    'Chinese',
+    'Cocos Islander',
+    'Colombian',
+    'Comoran',
+    'Cook Islander',
+    'Costa Rican',
+    'Croatian',
+    'Cuban',
+    'Curacaoan',
+    'Cypriot',
+    'Czech',
+    'Congolese',
+    'Danish',
+    'Djiboutian',
+    'Dominican (Note: Different from Dominican Republic)',
+    'Dominican',
+    'Timorese or East Timorese',
+    'Ecuadorian',
+    'Egyptian',
+    'Christmas Islander',
+    'Salvadoran',
+    'Equatorial Guinean',
+    'Eritrean',
+    'Ethiopian',
+    'Falkland Islander',
+    'Faroese',
+    'Fijian',
+    'Finnish',
+    'French',
+    'French Polynesian',
+    'Gabonese',
+    'Gambian',
+    'Georgian',
+    'German',
+    'Ghanaian',
+    'Gibraltarian',
+    'Greek',
+    'Greenlandic',
+    'Grenadian',
+    'Guamanian',
+    'Guatemalan',
+    'Estonian',
+    'Guernsey (or Channel Islander)',
+    'Guinean',
+    'Bissau-Guinean',
+    'Haitian',
+    'Honduran',
+    'Hong Konger',
+    'Hungarian',
+    'Icelander',
+    'Indian',
+    'Indonesian',
+    'Iranian',
+    'Iraqi',
+    'Irish',
+    'Manx',
+    'Israeli',
+    'Italian',
+    'Ivorian',
+    'Jamaican',
+    'Japanese',
+    'Jersey (or Channel Islander)',
+    'Jordanian',
+    'Guyanese',
+    'Kazakhstani',
+    'Kenyan',
+    'I-Kiribati',
+    'Kuwaiti',
+    'Kyrgyzstani',
+    'Lao or Laotian',
+    'Latvian',
+    'Lebanese',
+    'Basotho or Lesothan',
+    'Liberian',
+    'Libyan',
+    'Liechtensteiner',
+    'Lithuanian',
+    'Luxembourger',
+    'Macanese',
+    'Macedonian',
+    'Malagasy',
+    'Malawian',
+    'Malaysian',
+    'Maldivian',
+    'Malian',
+    'Kosovar',
+    'Maltese',
+    'Marshallese',
+    'Mauritanian',
+    'Mahoran or Mayotte',
+    'Mexican',
+    'Micronesian',
+    'Moldovan',
+    'Monégasque',
+    'Mongolian',
+    'Montenegrin',
+    'Montserratian',
+    'Moroccan',
+    'Mozambican',
+    'Burmese or Myanmarese',
+    'Namibian',
+    'Nauruan',
+    'Nepali or Nepalese',
+    'Dutch',
+    'Netherlands Antillean',
+    'New Caledonian',
+    'New Zealander',
+    'Mauritian',
+    'Nicaraguan',
+    'Nigerien',
+    'Nigerian',
+    'North Korean',
+    'Northern Marianan',
+    'Norwegian',
+    'Omani',
+    'Pakistani',
+    'Palauan',
+    'Palestinian',
+    'Panamanian',
+    'Papua New Guinean',
+    'Paraguayan',
+    'Peruvian',
+    'Filipino',
+    'Pitcairn Islander',
+    'Polish',
+    'Portuguese',
+    'Puerto Rican',
+    'Qatari',
+    'Congolese',
+    'Niuean',
+    'Réunionese or Réunionnais',
+    'Romanian',
+    'Russian',
+    'Barthélemois or Saint Barthélemy Islander',
+    'Saint Helenian',
+    'Kittitian or Nevisian',
+    'Saint Lucian',
+    'Saint-Martinoise',
+    'Saint-Pierrais or Miquelonnais',
+    'Vincentian or Vincy',
+    'Samoan',
+    'Sammarinese',
+    'São Toméan',
+    'Saudi or Saudi Arabian',
+    'Senegalese',
+    'Serbian',
+    'Seychellois',
+    'Sierra Leonean',
+    'Singaporean',
+    'Sint Maartener or Sint Maartian',
+    'Slovak',
+    'Rwandan',
+    'Slovenian',
+    'Solomon Islander',
+    'Somali',
+    'South Korean',
+    'South Sudanese',
+    'Spanish',
+    'Sri Lankan',
+    'Sudanese',
+    'Surinamese',
+    'Svalbardian or Jan Mayenian',
+    'Swazi',
+    'Swedish',
+    'Swiss',
+    'Syrian',
+    'Taiwanese',
+    'Tajikistani',
+    'Tanzanian',
+    'Thai',
+    'Togolese',
+    'Tokelauan',
+    'Tongan',
+    'South African',
+    'Trinidadian or Tobagonian',
+    'Tunisian',
+    'Turkish',
+    'Turks and Caicos Islander',
+    'Tuvaluan',
+    'Virgin Islander',
+    'Ugandan',
+    'Ukrainian',
+    'Emirati or Emirian',
+    'British',
+    'American',
+    'Uruguayan',
+    'Uzbekistani',
+    'Vanuatuan',
+    'Vatican (or Vatican City)',
+    'Venezuelan',
+    'Vietnamese',
+    'Wallisian or Futunan',
+    'Sahrawi',
+    'Turkmen',
+    'Zambian',
+    'Zimbabwean',
+    'Yemeni',
+];
+export function getNationalityOptions() {
+    return AllNationalities.map((v) => ({ key: v, text: v }));
+}

package/lib/Utilities/RouteUtils.d.ts

@@ -1,4 +1,4 @@
-import { default as React } from 'react';
+import React from "react";
 export declare enum FeatureStatus {
     placeholder = 0,
     alpha = 1,

package/lib/Utilities/RouteUtils.js

@@ -0,0 +1,223 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { matchPath, Route } from "react-router-dom";
+import { SuspenseRoute } from "../Components/SuspenseRoute";
+export var FeatureStatus;
+(function (FeatureStatus) {
+    FeatureStatus[FeatureStatus["placeholder"] = 0] = "placeholder";
+    FeatureStatus[FeatureStatus["alpha"] = 1] = "alpha";
+    FeatureStatus[FeatureStatus["beta"] = 2] = "beta";
+    FeatureStatus[FeatureStatus["release"] = 3] = "release";
+})(FeatureStatus || (FeatureStatus = {}));
+class RouteUtilsBase {
+    hasValidRole = (rolesRequired, rolesExists) => {
+        if (!rolesRequired || !rolesExists)
+            return true;
+        return rolesRequired.some((r) => rolesExists.includes(r));
+    };
+    hasValidPermission = (permissionsRequired, permissionsExists) => {
+        if (!permissionsRequired || !permissionsExists)
+            return true;
+        return permissionsRequired.some((p) => permissionsExists.includes(p));
+    };
+    hasValidRoleOrPermission = (rolesRequired, rolesExists, permissionsRequired, permissionsExists) => {
+        // If roles are specified and user has valid roles, grant access
+        if (rolesRequired && rolesExists && this.hasValidRole(rolesRequired, rolesExists)) {
+            return true;
+        }
+        // If roles are specified but user doesn't have valid roles, deny access
+        if (rolesRequired && rolesExists && rolesRequired.length > 0) {
+            return false;
+        }
+        // If no roles specified, check permissions
+        return this.hasValidPermission(permissionsRequired, permissionsExists);
+    };
+    hasValidFeatures = (featuresRequired, featuresExists) => {
+        if (featuresRequired === undefined || featuresRequired === null)
+            return true;
+        return featuresExists && featuresRequired.some((r) => featuresExists.includes(r));
+    };
+    hasValidBusinessType = (typesRequired, businessType) => {
+        if (typesRequired === undefined ||
+            typesRequired === null ||
+            businessType === undefined ||
+            businessType === null)
+            return true;
+        return typesRequired?.some((v) => v === businessType);
+    };
+    hasValidUserConfig = (configRequired, configExists) => {
+        if (configRequired == undefined || configRequired === null || !configExists)
+            return true;
+        return Object.keys(configExists).some((key) => {
+            return configExists[key] && configRequired?.some((v) => v === key);
+        });
+    };
+    hasValidUserParam = (paramsRequired, paramsExists) => {
+        if (paramsRequired == undefined || paramsRequired === null || !paramsExists)
+            return true;
+        return Object.keys(paramsExists).some((key) => {
+            return paramsExists[key] && paramsExists[key]?.enabled && paramsRequired?.some((v) => v === key);
+        });
+    };
+    hasValidTags = (tagsRequired, tagsExists) => {
+        if (!tagsRequired || !tagsExists)
+            return true;
+        return Object.keys(tagsExists).some((key) => {
+            return tagsExists[key] && tagsRequired?.some((v) => v === key);
+        });
+    };
+    isValidLink = (link, rolesExists, permissionsExists, featuresExists, businessType, configExists, paramsExists, tagsExists) => {
+        //check for user role or permission (roles take precedence)
+        if (!this.hasValidRoleOrPermission(link.roles, rolesExists, link.permissions, permissionsExists))
+            return false;
+        //check for app feature
+        if (!this.hasValidFeatures(link.features, featuresExists))
+            return false;
+        //check for user config
+        if (!this.hasValidUserConfig(link.userConfig, configExists))
+            return false;
+        //check for user params
+        if (!this.hasValidUserParam(link.userParams, paramsExists))
+            return false;
+        //check for business type
+        if (!this.hasValidBusinessType(link.businessTypes, businessType))
+            return false;
+        //check for tag
+        if (!this.hasValidTags(link.tags, tagsExists))
+            return false;
+        return true;
+    };
+    getPath = (link, trimUrl) => {
+        if (trimUrl && link?.url) {
+            return link.url.replace(trimUrl, '');
+        }
+        return link.url;
+    };
+    getRoutesFromGroups = (groups, SecureRoute, userRoles, userPermissions, features, businessType, userConfig, userParams, tags, trimUrl) => {
+        const routes = [];
+        for (const group of groups) {
+            routes.push(this.getRoutesFromGroup(group.links, SecureRoute, userRoles, userPermissions, features, businessType, userConfig, userParams, tags, trimUrl));
+        }
+        return routes;
+    };
+    getRoutesFromGroup = (links, SecureRoute, userRoles, userPermissions, features, businessType, userConfig, userParams, tags, trimUrl) => {
+        const routes = [];
+        for (const link of links) {
+            if (link.component) {
+                //check for valid link
+                if (!this.isValidLink(link, userRoles, userPermissions, features, businessType, userConfig, userParams, tags))
+                    continue;
+                //const exact = typeof link.exact === 'undefined' ? true : link.exact;
+                routes.push(link.roles || link.features ? (_jsx(Route, { path: this.getPath(link, trimUrl), element: _jsx(SecureRoute, { component: link.component, roles: link.roles }) }, link.key)) : (_jsx(Route, { path: this.getPath(link, trimUrl), element: _jsx(SuspenseRoute, { children: link.component }) }, link.key)));
+            }
+            //add nested links
+            if (link.links) {
+                routes.push(...this.getRoutesFromGroup(link.links, SecureRoute, userRoles, userPermissions, features, businessType, userConfig, userParams, tags, trimUrl));
+            }
+        }
+        return routes;
+    };
+    getLinksFromGroups = (links, userRoles, userPermissions, features, businessType, userConfig, userParams, currentPath, params, tags) => {
+        const groups = [];
+        for (const link of links) {
+            //check for valid link
+            if (!this.isValidLink(link, userRoles, userPermissions, features, businessType, userConfig, userParams, tags))
+                continue;
+            groups.push(link);
+            //add nested links
+            if (link.links) {
+                link.links = this.getLinksFromGroup(link.links, userRoles, userPermissions, features, businessType, userConfig, userParams, currentPath, params, tags);
+            }
+        }
+        return groups;
+    };
+    getLinksFromGroup = (links, userRoles, userPermissions, features, businessType, userConfig, userParams, currentPath, params, tags) => {
+        const routes = [];
+        for (const link of links) {
+            //check for valid link
+            if (!this.isValidLink(link, userRoles, userPermissions, features, businessType, userConfig, userParams, tags))
+                continue;
+            let url = link.url, activeUrl = link.activeUrl;
+            if (url && params) {
+                for (const key in params) {
+                    url = url?.replace(`:${key}`, params[key]);
+                    if (activeUrl)
+                        activeUrl = activeUrl.replace(`:${key}`, params[key]);
+                }
+            }
+            link.url = url;
+            link.activeUrl = activeUrl;
+            routes.push(link);
+            //add nested links
+            if (link.links) {
+                if (currentPath && link.activeUrl) {
+                    link.isExpanded = link.url === currentPath || currentPath.indexOf(link.activeUrl) === 0;
+                }
+                link.links = this.getLinksFromGroup(link.links, userRoles, userPermissions, features, businessType, userConfig, userParams, currentPath, params, tags);
+            }
+        }
+        return routes;
+    };
+    getRoutesFromLinks = (links, SecureRoute, userRoles, userPermissions, features, businessType, userConfig, userParams, tags, trimUrl) => {
+        const routes = [];
+        for (const link of links) {
+            if (link.component) {
+                //check for valid link
+                if (!this.isValidLink(link, userRoles, userPermissions, features, businessType, userConfig, userParams, tags))
+                    continue;
+                //const exact = typeof link.exact === 'undefined' ? true : link.exact;
+                routes.push(link.roles ? (_jsx(Route, { path: this.getPath(link, trimUrl), element: _jsx(SecureRoute, { component: link.component, roles: link.roles }) }, link.key)) : (_jsx(Route, { path: this.getPath(link, trimUrl) || '#', element: _jsx(SuspenseRoute, { children: link.component }) }, link.key)));
+            }
+            //add nested links
+            if (link.links) {
+                routes.push(...this.getRoutesFromLinks(link.links, SecureRoute, userRoles, userPermissions, features, businessType, userConfig, userParams, tags, trimUrl));
+            }
+        }
+        return routes;
+    };
+    getLinksFromLinks = (links, userRoles, userPermissions, features, businessType, userConfig, userParams, currentPath, params, tags) => {
+        const routes = [];
+        for (const link of links) {
+            //check for valid link
+            if (!this.isValidLink(link, userRoles, userPermissions, features, businessType, userConfig, userParams, tags))
+                continue;
+            let url = link.url, activeUrl = link.activeUrl;
+            if (url && params) {
+                for (const key in params) {
+                    url = url?.replace(`:${key}`, params[key]);
+                    if (activeUrl)
+                        activeUrl = activeUrl.replace(`:${key}`, params[key]);
+                }
+            }
+            link.url = url;
+            link.activeUrl = activeUrl;
+            routes.push(link);
+            //add nested links
+            if (link.links) {
+                if (currentPath && link.activeUrl) {
+                    link.isExpanded = link.url === currentPath || currentPath.indexOf(link.activeUrl) === 0;
+                }
+                link.links = this.getLinksFromLinks(link.links, userRoles, userPermissions, features, businessType, userConfig, userParams, currentPath, params, tags);
+            }
+        }
+        return routes;
+    };
+    getSelectedNavKey = (pagesGroup, currentPath) => {
+        let selectedLink = undefined;
+        for (const group of pagesGroup) {
+            selectedLink = group.links
+                .flatMap((l) => {
+                if (l.links)
+                    return l.links;
+                else
+                    return [l];
+            })
+                .find((l) => l.url === currentPath ||
+                (l.activeUrls && l.activeUrls.some((la) => matchPath(la, currentPath))) ||
+                matchPath(l.url, currentPath));
+            if (selectedLink)
+                break;
+        }
+        return selectedLink?.key;
+    };
+}
+export const RouteUtils = new RouteUtilsBase();