ngx-material-navigation 0.0.1

package/esm2020/utilities/nav.utilities.mjs

@@ -0,0 +1,198 @@
+/**
+ * Contains HelperMethods around handling Navigation.
+ */
+export class NavUtilities {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    static asTitle(element) {
+        return element;
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    static asAngularRoute(route) {
+        return route;
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    static asStringRoute(route) {
+        return route;
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    static asInternalLink(element) {
+        return element;
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    static asExternalLink(element) {
+        return element;
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    static asMenu(element) {
+        return element;
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    static asButton(element) {
+        return element;
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    static asImage(element) {
+        return element;
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    static asImageWithInternalLink(element) {
+        return element;
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    static asImageWithExternalLink(element) {
+        return element;
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    static asTitleWithInternalLink(element) {
+        return element;
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    static asTitleWithExternalLink(element) {
+        return element;
+    }
+    /**
+     * Checks if the provided element is a NavInternalLink.
+     *
+     * @param element - The element to check.
+     * @returns Whether or not the given element is a NavInternalLink.
+     */
+    static isInternalLink(element) {
+        if (element.route) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Checks if the provided element is a NavMenu.
+     *
+     * @param element - The element to check.
+     * @returns Whether or not the given element is a NavMenu.
+     */
+    static isMenu(element) {
+        if (element.elements) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Checks if the provided value is an angular route.
+     *
+     * @param route - The value to check.
+     * @returns Whether or not the given value is an angular route.
+     */
+    static isAngularRoute(route) {
+        if (route.path) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Checks if the provided element is a NavElement.
+     *
+     * @param value - The element to check.
+     * @returns Whether or not the given element is a NavElement.
+     */
+    static isNavElement(value) {
+        if (value.type) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Gets the angular routes.
+     * Extracts them from the navbarRows and adds any additional routes provided in additionalRoutes.
+     *
+     * @param navbarRows - The NavbarRows used as a configuration for the navbar element.
+     * @param additionalRoutes - Any additional routes that aren't included in the NavbarRows.
+     * @returns All found angular routes.
+     */
+    static getAngularRoutes(navbarRows = [], additionalRoutes = []) {
+        let allRoutes = [];
+        allRoutes = allRoutes.concat(NavUtilities.getRoutesFromNavbar(navbarRows));
+        allRoutes = allRoutes.concat(additionalRoutes);
+        // Filters to only contain unique paths
+        const uniquePaths = [];
+        const res = [];
+        for (const route of allRoutes) {
+            if (!uniquePaths.find(r => r === route.path)) {
+                res.push(route);
+            }
+        }
+        return res;
+    }
+    static getRoutesFromNavbar(navbarRows) {
+        let res = [];
+        for (const row of navbarRows) {
+            res = res.concat(NavUtilities.getRoutesFromElements(row.elements));
+        }
+        ;
+        return res;
+    }
+    static getRoutesFromElements(elements) {
+        let res = [];
+        const internalLinks = elements.filter(e => NavUtilities.isInternalLink(e));
+        const angularRoutes = internalLinks.filter(l => NavUtilities.isAngularRoute(l.route)).map(l => l.route);
+        res = res.concat(angularRoutes);
+        const menus = elements.filter(e => NavUtilities.isMenu(e));
+        for (const menu of menus) {
+            res = res.concat(NavUtilities.getRoutesFromElements(menu.elements));
+        }
+        return res;
+    }
+    /**
+     * Get all elements at the provided position with the provided screenWidth from the given elements.
+     *
+     * @param position - The position for which to get the elements.
+     * @param screenWidth - The current screen width. Is needed to hide elements that are already collapsed into the sidenav.
+     * @param rows - The rows to get the elements from.
+     * @returns All Elements for the provided input.
+     */
+    static getNavbarElements(position, screenWidth, rows) {
+        if (!rows || !rows.length) {
+            return [];
+        }
+        let res = [];
+        for (const row of rows) {
+            res = res.concat(row.elements);
+        }
+        if (position === 'left') {
+            res = res.filter(e => !e.position || e.position === position);
+        }
+        else {
+            res = res.filter(e => e.position === position);
+        }
+        switch (screenWidth) {
+            case 'lg':
+                return res.filter(e => e.collapse !== 'always' && e.collapse !== 'lg');
+            case 'md':
+                return res.filter(e => e.collapse !== 'always' && e.collapse !== 'lg' && e.collapse !== 'md');
+            case 'sm':
+                return res.filter(e => e.collapse !== 'always' && e.collapse !== 'lg' && e.collapse !== 'md' && e.collapse !== 'sm');
+        }
+    }
+    /**
+     * Gets all the elements to display in the sidenav.
+     *
+     * @param screenWidth - The current screen width.
+     * @param rows - The rows to get the elements from.
+     * @returns The NavElements to display in the sidenav.
+     */
+    static getSidenavElements(screenWidth, rows) {
+        if (!rows || !rows.length) {
+            return [];
+        }
+        let res = [];
+        for (const row of rows) {
+            res = res.concat(row.elements);
+        }
+        switch (screenWidth) {
+            case 'lg':
+                return res.filter(e => e.collapse === 'always' || e.collapse === 'lg');
+            case 'md':
+                return res.filter(e => e.collapse === 'always' || e.collapse === 'lg' || e.collapse === 'md');
+            case 'sm':
+                return res.filter(e => e.collapse === 'always' || e.collapse === 'lg' || e.collapse === 'md' || e.collapse === 'sm');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav.utilities.js","sourceRoot":"","sources":["../../../../projects/ngx-material-navigation/src/utilities/nav.utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import { Route, Routes } from '@angular/router';\r\nimport { NavButton } from '../models/nav-button.model';\r\nimport { NavMenu, NavMenuElement } from '../models/nav-menu.model';\r\nimport { NavImage, NavImageWithExternalLink, NavImageWithInternalLink } from '../models/nav-image.model';\r\nimport { NavTitle, NavTitleWithExternalLink, NavTitleWithInternalLink } from '../models/nav-title.model';\r\nimport { NavElement } from '../models/nav.model';\r\nimport { NavExternalLink, NavInternalLink } from '../models/nav-link.model';\r\nimport { NavbarRow } from '../models/navbar.model';\r\n\r\n/**\r\n * Contains HelperMethods around handling Navigation.\r\n */\r\nexport abstract class NavUtilities {\r\n\r\n    // eslint-disable-next-line jsdoc/require-jsdoc\r\n    static asTitle(element: NavElement): NavTitle {\r\n        return element as NavTitle;\r\n    }\r\n\r\n    // eslint-disable-next-line jsdoc/require-jsdoc\r\n    static asAngularRoute(route: Route | string): Route {\r\n        return route as Route;\r\n    }\r\n\r\n    // eslint-disable-next-line jsdoc/require-jsdoc\r\n    static asStringRoute(route: Route | string): string {\r\n        return route as string;\r\n    }\r\n\r\n    // eslint-disable-next-line jsdoc/require-jsdoc\r\n    static asInternalLink(element: NavElement | NavMenuElement): NavInternalLink {\r\n        return element as NavInternalLink;\r\n    }\r\n\r\n    // eslint-disable-next-line jsdoc/require-jsdoc\r\n    static asExternalLink(element: NavElement | NavMenuElement): NavExternalLink {\r\n        return element as NavExternalLink;\r\n    }\r\n\r\n    // eslint-disable-next-line jsdoc/require-jsdoc\r\n    static asMenu(element: NavElement | NavMenuElement): NavMenu {\r\n        return element as NavMenu;\r\n    }\r\n\r\n    // eslint-disable-next-line jsdoc/require-jsdoc\r\n    static asButton(element: NavElement): NavButton {\r\n        return element as NavButton;\r\n    }\r\n\r\n    // eslint-disable-next-line jsdoc/require-jsdoc\r\n    static asImage(element: NavElement): NavImage {\r\n        return element as NavImage;\r\n    }\r\n\r\n    // eslint-disable-next-line jsdoc/require-jsdoc\r\n    static asImageWithInternalLink(element: NavElement): NavImageWithInternalLink {\r\n        return element as NavImageWithInternalLink;\r\n    }\r\n\r\n    // eslint-disable-next-line jsdoc/require-jsdoc\r\n    static asImageWithExternalLink(element: NavElement): NavImageWithExternalLink {\r\n        return element as NavImageWithExternalLink;\r\n    }\r\n\r\n    // eslint-disable-next-line jsdoc/require-jsdoc\r\n    static asTitleWithInternalLink(element: NavElement): NavTitleWithInternalLink {\r\n        return element as NavTitleWithInternalLink;\r\n    }\r\n\r\n    // eslint-disable-next-line jsdoc/require-jsdoc\r\n    static asTitleWithExternalLink(element: NavElement): NavTitleWithExternalLink {\r\n        return element as NavTitleWithExternalLink;\r\n    }\r\n\r\n    /**\r\n     * Checks if the provided element is a NavInternalLink.\r\n     *\r\n     * @param element - The element to check.\r\n     * @returns Whether or not the given element is a NavInternalLink.\r\n     */\r\n    static isInternalLink(element: NavElement): element is NavInternalLink {\r\n        if ((element as NavInternalLink).route) {\r\n            return true;\r\n        }\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Checks if the provided element is a NavMenu.\r\n     *\r\n     * @param element - The element to check.\r\n     * @returns Whether or not the given element is a NavMenu.\r\n     */\r\n    static isMenu(element: NavElement): element is NavMenu {\r\n        if ((element as NavMenu).elements) {\r\n            return true;\r\n        }\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Checks if the provided value is an angular route.\r\n     *\r\n     * @param route - The value to check.\r\n     * @returns Whether or not the given value is an angular route.\r\n     */\r\n    static isAngularRoute(route: Route | string): route is Route {\r\n        if ((route as Route).path) {\r\n            return true;\r\n        }\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Checks if the provided element is a NavElement.\r\n     *\r\n     * @param value - The element to check.\r\n     * @returns Whether or not the given element is a NavElement.\r\n     */\r\n    static isNavElement(value: NavElement | NavbarRow): value is NavElement {\r\n        if ((value as NavElement).type) {\r\n            return true;\r\n        }\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Gets the angular routes.\r\n     * Extracts them from the navbarRows and adds any additional routes provided in additionalRoutes.\r\n     *\r\n     * @param navbarRows - The NavbarRows used as a configuration for the navbar element.\r\n     * @param additionalRoutes - Any additional routes that aren't included in the NavbarRows.\r\n     * @returns All found angular routes.\r\n     */\r\n    static getAngularRoutes(navbarRows: NavbarRow[] = [], additionalRoutes: Routes = []): Routes {\r\n        let allRoutes: Routes = [];\r\n        allRoutes = allRoutes.concat(NavUtilities.getRoutesFromNavbar(navbarRows));\r\n        allRoutes = allRoutes.concat(additionalRoutes);\r\n        // Filters to only contain unique paths\r\n        const uniquePaths: string[] = [];\r\n        const res: Routes = [];\r\n        for (const route of allRoutes) {\r\n            if (!uniquePaths.find(r => r === route.path)) {\r\n                res.push(route);\r\n            }\r\n        }\r\n        return res;\r\n    }\r\n\r\n    private static getRoutesFromNavbar(navbarRows: NavbarRow[]): Routes {\r\n        let res: Routes = [];\r\n        for (const row of navbarRows) {\r\n            res = res.concat(NavUtilities.getRoutesFromElements(row.elements));\r\n        };\r\n        return res;\r\n    }\r\n\r\n    private static getRoutesFromElements(elements: NavElement[]): Routes {\r\n        let res: Routes = [];\r\n        const internalLinks: NavInternalLink[] = elements.filter(e => NavUtilities.isInternalLink(e)) as NavInternalLink[];\r\n        const angularRoutes: Routes = internalLinks.filter(l => NavUtilities.isAngularRoute(l.route)).map(l => l.route) as Routes;\r\n        res = res.concat(angularRoutes);\r\n        const menus: NavMenu[] = elements.filter(e => NavUtilities.isMenu(e)) as NavMenu[];\r\n        for (const menu of menus) {\r\n            res = res.concat(NavUtilities.getRoutesFromElements(menu.elements as NavElement[]));\r\n        }\r\n        return res;\r\n    }\r\n\r\n    /**\r\n     * Get all elements at the provided position with the provided screenWidth from the given elements.\r\n     *\r\n     * @param position - The position for which to get the elements.\r\n     * @param screenWidth - The current screen width. Is needed to hide elements that are already collapsed into the sidenav.\r\n     * @param rows - The rows to get the elements from.\r\n     * @returns All Elements for the provided input.\r\n     */\r\n    static getNavbarElements(\r\n        position: 'left' | 'center' | 'right',\r\n        screenWidth: 'lg' | 'md' | 'sm',\r\n        rows?: NavbarRow[]\r\n    ): NavElement[] {\r\n        if (!rows || !rows.length) {\r\n            return [];\r\n        }\r\n        let res: NavElement[] = [];\r\n        for (const row of rows ) {\r\n            res = res.concat(row.elements);\r\n        }\r\n\r\n        if (position === 'left') {\r\n            res = res.filter(e => !e.position || e.position === position);\r\n        }\r\n        else {\r\n            res = res.filter(e => e.position === position);\r\n        }\r\n        switch (screenWidth) {\r\n            case 'lg':\r\n                return res.filter(e => e.collapse !== 'always' && e.collapse !== 'lg');\r\n            case 'md':\r\n                return res.filter(e => e.collapse !== 'always' && e.collapse !== 'lg' && e.collapse !== 'md');\r\n            case 'sm':\r\n                return res.filter(e => e.collapse !== 'always' && e.collapse !== 'lg' && e.collapse !== 'md' && e.collapse !== 'sm');\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Gets all the elements to display in the sidenav.\r\n     *\r\n     * @param screenWidth - The current screen width.\r\n     * @param rows - The rows to get the elements from.\r\n     * @returns The NavElements to display in the sidenav.\r\n     */\r\n    static getSidenavElements(screenWidth: 'lg' | 'md' | 'sm', rows?: NavbarRow[]): NavElement[] {\r\n        if (!rows || !rows.length) {\r\n            return [];\r\n        }\r\n        let res: NavElement[] = [];\r\n        for (const row of rows) {\r\n            res = res.concat(row.elements);\r\n        }\r\n        switch (screenWidth) {\r\n            case 'lg':\r\n                return res.filter(e => e.collapse === 'always' || e.collapse === 'lg');\r\n            case 'md':\r\n                return res.filter(e => e.collapse === 'always' || e.collapse === 'lg' || e.collapse === 'md');\r\n            case 'sm':\r\n                return res.filter(e => e.collapse === 'always' || e.collapse === 'lg' || e.collapse === 'md' || e.collapse === 'sm');\r\n        }\r\n    }\r\n}"]}