@capsitech/react-utilities 0.1.2

package/lib/Utilities/RouteUtils.js

@@ -0,0 +1,206 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { matchPath, Route } from "react-router-dom";
+import { SuspenseRoute } from "./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));
+    };
+    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, featuresExists, businessType, configExists, paramsExists, tagsExists) => {
+        //check for user role
+        if (!this.hasValidRole(link.roles, rolesExists))
+            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, roles, features, businessType, userConfig, userParams, tags, trimUrl) => {
+        const routes = [];
+        for (const group of groups) {
+            routes.push(this.getRoutesFromGroup(group.links, SecureRoute, roles, features, businessType, userConfig, userParams, tags, trimUrl));
+        }
+        return routes;
+    };
+    getRoutesFromGroup = (links, SecureRoute, roles, features, businessType, userConfig, userParams, tags, trimUrl) => {
+        const routes = [];
+        for (const link of links) {
+            if (link.component) {
+                //check for valid link
+                if (!this.isValidLink(link, roles, 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, roles, features, businessType, userConfig, userParams, tags, trimUrl));
+            }
+        }
+        return routes;
+    };
+    getLinksFromGroups = (links, roles, features, businessType, userConfig, userParams, currentPath, params, tags) => {
+        const groups = [];
+        for (const link of links) {
+            //check for valid link
+            if (!this.isValidLink(link, roles, features, businessType, userConfig, userParams, tags))
+                continue;
+            groups.push(link);
+            //add nested links
+            if (link.links) {
+                link.links = this.getLinksFromGroup(link.links, roles, features, businessType, userConfig, userParams, currentPath, params, tags);
+            }
+        }
+        return groups;
+    };
+    getLinksFromGroup = (links, roles, features, businessType, userConfig, userParams, currentPath, params, tags) => {
+        const routes = [];
+        for (const link of links) {
+            //check for valid link
+            if (!this.isValidLink(link, roles, 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, roles, features, businessType, userConfig, userParams, currentPath, params, tags);
+            }
+        }
+        return routes;
+    };
+    getRoutesFromLinks = (links, SecureRoute, roles, features, businessType, userConfig, userParams, tags, trimUrl) => {
+        const routes = [];
+        for (const link of links) {
+            if (link.component) {
+                //check for valid link
+                if (!this.isValidLink(link, roles, 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, roles, features, businessType, userConfig, userParams, tags, trimUrl));
+            }
+        }
+        return routes;
+    };
+    getLinksFromLinks = (links, roles, features, businessType, userConfig, userParams, currentPath, params, tags) => {
+        const routes = [];
+        for (const link of links) {
+            //check for valid link
+            if (!this.isValidLink(link, roles, 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, roles, 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();

package/lib/Utilities/SuspenseRoute.d.ts

@@ -0,0 +1,7 @@
+interface ISuspenseRouteProps {
+    label?: string;
+    children?: any;
+    fallback?: any;
+}
+export declare const SuspenseRoute: ({ children: Component, label, fallback: FallbackComponent, }: ISuspenseRouteProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/Utilities/SuspenseRoute.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+const isSuspenseComponent = (component) => typeof component === "object" &&
+    component &&
+    component.hasOwnProperty("$$typeof") &&
+    component.hasOwnProperty("_payload") &&
+    component.hasOwnProperty("_init");
+export const SuspenseRoute = ({ children: Component, label = "Loading components...", fallback: FallbackComponent, }) => {
+    return isSuspenseComponent(Component) ? (_jsx(React.Suspense, { fallback: _jsx(FallbackComponent, { label: label }), children: _jsx(Component, {}) })) : (_jsx(Component, {}));
+};

package/lib/Utilities/TimeZones.d.ts

@@ -0,0 +1,10 @@
+export interface ITimeZone {
+    id: string;
+    name: string;
+    utc: string;
+}
+export declare const AllTimeZones: ITimeZone[];
+export declare function getTimeZoneOptions(): {
+    key: string;
+    text: string;
+}[];