@mediusinc/mng-commons 4.2.0 → 5.0.0-rc.0

package/esm2022/core/router/route-builder.mjs

@@ -0,0 +1,336 @@
+import { CommonsInternalError } from '../error/error.model';
+import { permissionGuard } from '../security/permission.guard';
+import { RouteUtil } from '../utils/route.util';
+export class RouteBuilder {
+    constructor(route) {
+        this.routePath = [];
+        this.routeData = { breadcrumb: null };
+        this.children = [];
+        this.menuItemChildren = [];
+        this.menuItemChildrenAfter = []; // append after route children
+        this.route = route;
+        if (this.route.path && this.route.path.length > 0) {
+            this.routePath = [this.route.path];
+        }
+    }
+    static create(path, component) {
+        return new RouteBuilder({
+            path: path,
+            component: component
+        });
+    }
+    static createRedirect(path, redirectTo, pathMatch = 'prefix') {
+        return new RouteBuilder({
+            path: path,
+            redirectTo: redirectTo,
+            pathMatch: pathMatch
+        });
+    }
+    static createLazyRouteModule(path, loadChildren, canMatch) {
+        const route = { path: path, loadChildren: loadChildren };
+        if (canMatch?.length) {
+            route.canMatch = canMatch;
+        }
+        return new RouteBuilder(route);
+    }
+    static createLazyRouteComponent(path, loadComponent, canMatch) {
+        const route = { path: path, loadComponent: loadComponent };
+        if (canMatch?.length) {
+            route.canMatch = canMatch;
+        }
+        return new RouteBuilder(route);
+    }
+    static createFromRoute(route) {
+        return new RouteBuilder(route);
+    }
+    withRoot(routesBuilder) {
+        this.root = routesBuilder;
+        return this;
+    }
+    withParent(parent) {
+        this.parent = parent;
+        this.routePath = RouteUtil.removeEmptyPathSegments([...this.parent.routePath, this.route.path ?? '']);
+        return this;
+    }
+    withBreadcrumb(breadcrumb) {
+        this.breadcrumb = breadcrumb;
+        this.routeData.breadcrumb = breadcrumb;
+        return this;
+    }
+    withPageTitle(pageTitle) {
+        this.pageTitle = pageTitle;
+        this.routeData.pageTitle = pageTitle;
+        return this;
+    }
+    withRedirectTo(redirectTo) {
+        this.route.redirectTo = redirectTo;
+        return this;
+    }
+    withPathMatch(pathMatch) {
+        this.route.pathMatch = pathMatch;
+        return this;
+    }
+    withTitle(title) {
+        this.withPageTitle(title);
+        this.withBreadcrumb(title);
+        return this;
+    }
+    withCanActivate(diToken) {
+        if (!this.route.canActivate) {
+            this.route.canActivate = [];
+        }
+        this.route.canActivate.push(diToken);
+        return this;
+    }
+    withCanDeactivate(diToken) {
+        if (!this.route.canDeactivate) {
+            this.route.canDeactivate = [];
+        }
+        this.route.canDeactivate.push(diToken);
+        return this;
+    }
+    withResolver(diToken, name) {
+        if (!this.route.resolve) {
+            this.route.resolve = {};
+        }
+        this.route.resolve[name] = diToken;
+        return this;
+    }
+    withProvider(provider) {
+        if (!this.route.providers) {
+            this.route.providers = [];
+        }
+        this.route.providers.push(provider);
+        return this;
+    }
+    withData(data) {
+        if (!data.breadcrumb) {
+            data.breadcrumb = null;
+        }
+        this.routeData = data;
+        return this;
+    }
+    withCommonsMenuItem(menuItem) {
+        this.menuItem = menuItem;
+        return this;
+    }
+    withMenuItem(icon, label, routerLink, breadcrumb = false) {
+        this.menuItem = this.createMenuItem(icon, label, routerLink);
+        if (breadcrumb && label) {
+            this.withBreadcrumb({
+                label: label
+            });
+        }
+        return this;
+    }
+    /**
+     * Adds menu item child to this instance of menu item.
+     * @param label Label.
+     * @param icon Icon.
+     * @param routerLink Router link.
+     * @param afterRouteChildren If false, menu item child will be appended before route children menu items, at the end otherwise.
+     */
+    withMenuItemChild(label, icon, routerLink, afterRouteChildren = false) {
+        if (afterRouteChildren) {
+            this.menuItemChildrenAfter.push(this.createMenuItem(icon, label, routerLink));
+        }
+        else {
+            this.menuItemChildren.push(this.createMenuItem(icon, label, routerLink));
+        }
+        return this;
+    }
+    /**
+     * Adds menu item child to this instance of menu item.
+     * @param menuItem Configuration object for menu item.
+     * @param afterRouteChildren If false, menu item child will be appended before route children menu items, at the end otherwise.
+     */
+    withCommonsMenuItemChild(menuItem, afterRouteChildren = false) {
+        if (afterRouteChildren) {
+            this.menuItemChildrenAfter.push(menuItem);
+        }
+        else {
+            this.menuItemChildren.push(menuItem);
+        }
+        return this;
+    }
+    withMenuItemLazyChildren() {
+        if (!this.menuItem) {
+            this.menuItem = {};
+        }
+        this.menuItem.lazyChildren = true;
+        return this;
+    }
+    withPermissions(permissions) {
+        this.permissions = permissions;
+        this.withCanActivate(permissionGuard);
+        return this;
+    }
+    addChild(path, component) {
+        const childRouteBuilder = RouteBuilder.create(path, component);
+        this.addChildBuilder(childRouteBuilder);
+        return childRouteBuilder;
+    }
+    addChildBuilder(builder) {
+        builder.withParent(this);
+        if (this.root) {
+            builder.withRoot(this.root);
+        }
+        this.children.push(builder);
+        return this;
+    }
+    toParent() {
+        if (!this.parent) {
+            throw new CommonsInternalError('Parent was not provided.', { name: 'RouteBuilder error' });
+        }
+        return this.parent;
+    }
+    toRoot() {
+        if (!this.root) {
+            throw new CommonsInternalError('Root was not provided.', { name: 'RouteBuilderError' });
+        }
+        return this.root;
+    }
+    finish() {
+        return this.toRoot();
+    }
+    build() {
+        const angularRoute = {
+            ...this.route
+        };
+        if (angularRoute.data) {
+            angularRoute.data = {
+                ...angularRoute.data,
+                ...this.routeData
+            };
+        }
+        else {
+            angularRoute.data = { ...this.routeData };
+        }
+        // append permissions if not already in route data
+        if (this.permissions && !angularRoute.data.permissions) {
+            angularRoute.data.permissions = this.permissions;
+        }
+        const menu = this.buildMenu();
+        if (menu.length > 0) {
+            angularRoute.data.menuItems = menu;
+        }
+        if ((this.route.children?.length ?? 0) > 0 || this.children.length > 0) {
+            // route has children
+            angularRoute.children = [];
+            if (this.route.children?.length) {
+                angularRoute.children.push(...this.route.children);
+            }
+            if (this.children.length) {
+                for (const childRoute of this.children) {
+                    angularRoute.children.push(childRoute.build());
+                }
+            }
+        }
+        if (this.route.canActivate) {
+            angularRoute.canActivate = [...this.route.canActivate];
+        }
+        if (this.route.canActivateChild) {
+            angularRoute.canActivateChild = [...this.route.canActivateChild];
+        }
+        if (this.route.canLoad) {
+            angularRoute.canLoad = [...this.route.canLoad];
+        }
+        if (this.route.canDeactivate) {
+            angularRoute.canDeactivate = [...this.route.canDeactivate];
+        }
+        if (this.route.resolve) {
+            angularRoute.resolve = { ...this.route.resolve };
+        }
+        return angularRoute;
+    }
+    buildMenu() {
+        const menuItemBuild = this.menuItem ? { ...this.menuItem } : null;
+        const routeChildrenMenuItems = this.children.flatMap(child => child.buildMenu());
+        const menuItemChildren = [];
+        const menuItemChildrenBuild = [];
+        if (menuItemBuild?.items) {
+            menuItemChildrenBuild.push(...menuItemBuild.items);
+        }
+        const processMenuItemChild = (child) => {
+            const finalChild = { ...child };
+            if (typeof finalChild.routerLink === 'undefined') {
+                finalChild.routerLink = this.routePath;
+            }
+            if (typeof finalChild.routerLink === 'string') {
+                finalChild.routerLink = [finalChild.routerLink];
+            }
+            if (finalChild.routerLink) {
+                finalChild.routerLink = RouteUtil.removeEmptyPathSegments(finalChild.routerLink);
+            }
+            return finalChild;
+        };
+        this.menuItemChildren.forEach(child => menuItemChildren.push(processMenuItemChild(child)));
+        const menuItemChildrenAfterBuild = this.menuItemChildrenAfter.map(child => processMenuItemChild(child));
+        menuItemChildrenBuild.push(...menuItemChildren, ...routeChildrenMenuItems, ...menuItemChildrenAfterBuild);
+        if (!menuItemBuild) {
+            return menuItemChildrenBuild;
+        }
+        menuItemBuild.label = menuItemBuild.label ?? this.pageTitle;
+        if (typeof menuItemBuild.routerLink === 'string') {
+            menuItemBuild.routerLink = [menuItemBuild.routerLink];
+        }
+        menuItemBuild.routerLink = RouteUtil.removeEmptyPathSegments(menuItemBuild.routerLink ?? this.routePath);
+        if (menuItemChildrenBuild.length > 0) {
+            menuItemBuild.items = menuItemChildrenBuild;
+        }
+        if (!menuItemBuild.guards) {
+            const guards = this.findMenuItemGuards();
+            if (guards.length > 0) {
+                menuItemBuild.guards = guards;
+            }
+        }
+        if (!menuItemBuild.permissions) {
+            menuItemBuild.permissions = this.findMenuItemPermissions();
+        }
+        return [menuItemBuild];
+    }
+    createMenuItem(icon, label, routerLink) {
+        const menuItem = {};
+        if (icon) {
+            menuItem.icon = icon;
+        }
+        if (label) {
+            menuItem.label = label;
+        }
+        if (routerLink) {
+            menuItem.routerLink = routerLink;
+        }
+        return menuItem;
+    }
+    findMenuItemGuards() {
+        const guards = [];
+        if (this.route.canActivate?.length) {
+            guards.push(...this.route.canActivate);
+        }
+        if (this.parent) {
+            // Check for parent guards that should be included in decision to hide menu item!
+            // Some parent routes might have guards, but no menu items, so this guards must be taken into account here,
+            // because there is no parent menu item to hide.
+            this.parent.findMenuItemGuards().forEach(g => {
+                if (guards.indexOf(g) < 0) {
+                    guards.push(g);
+                }
+            });
+        }
+        return guards;
+    }
+    findMenuItemPermissions() {
+        if (this.menuItem?.permissions) {
+            return this.menuItem.permissions;
+        }
+        if (this.routeData.permissions) {
+            // this is already built
+            return this.routeData.permissions;
+        }
+        if (this.permissions) {
+            return this.permissions;
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-builder.js","sourceRoot":"","sources":["../../../../core/src/router/route-builder.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,oBAAoB,EAAC,MAAM,sBAAsB,CAAC;AAE1D,OAAO,EAAC,eAAe,EAAC,MAAM,8BAA8B,CAAC;AAE7D,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAI9C,MAAM,OAAO,YAAY;IAiBrB,YAAsB,KAAY;QAf1B,cAAS,GAAkB,EAAE,CAAC;QAC5B,cAAS,GAAqB,EAAC,UAAU,EAAE,IAAI,EAAC,CAAC;QAGnD,aAAQ,GAAwB,EAAE,CAAC;QAGnC,qBAAgB,GAA2B,EAAE,CAAC;QAC9C,0BAAqB,GAA2B,EAAE,CAAC,CAAC,8BAA8B;QAQtF,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;YAC/C,IAAI,CAAC,SAAS,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;SACtC;IACL,CAAC;IAEM,MAAM,CAAC,MAAM,CAAC,IAAY,EAAE,SAAoB;QACnD,OAAO,IAAI,YAAY,CAAC;YACpB,IAAI,EAAE,IAAI;YACV,SAAS,EAAE,SAAS;SACvB,CAAC,CAAC;IACP,CAAC;IAEM,MAAM,CAAC,cAAc,CAAC,IAAY,EAAE,UAAkB,EAAE,YAA+B,QAAQ;QAClG,OAAO,IAAI,YAAY,CAAC;YACpB,IAAI,EAAE,IAAI;YACV,UAAU,EAAE,UAAU;YACtB,SAAS,EAAE,SAAS;SACvB,CAAC,CAAC;IACP,CAAC;IAEM,MAAM,CAAC,qBAAqB,CAAC,IAAY,EAAE,YAA0B,EAAE,QAAqB;QAC/F,MAAM,KAAK,GAAU,EAAC,IAAI,EAAE,IAAI,EAAE,YAAY,EAAE,YAAY,EAAC,CAAC;QAC9D,IAAI,QAAQ,EAAE,MAAM,EAAE;YAClB,KAAK,CAAC,QAAQ,GAAG,QAAQ,CAAC;SAC7B;QACD,OAAO,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC;IACnC,CAAC;IAEM,MAAM,CAAC,wBAAwB,CAClC,IAAY,EACZ,aAAqJ,EACrJ,QAAqB;QAErB,MAAM,KAAK,GAAU,EAAC,IAAI,EAAE,IAAI,EAAE,aAAa,EAAE,aAAa,EAAC,CAAC;QAChE,IAAI,QAAQ,EAAE,MAAM,EAAE;YAClB,KAAK,CAAC,QAAQ,GAAG,QAAQ,CAAC;SAC7B;QACD,OAAO,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC;IACnC,CAAC;IAEM,MAAM,CAAC,eAAe,CAAC,KAAY;QACtC,OAAO,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC;IACnC,CAAC;IAEM,QAAQ,CAAC,aAA4B;QACxC,IAAI,CAAC,IAAI,GAAG,aAAa,CAAC;QAC1B,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,UAAU,CAAC,MAAoB;QAClC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC,uBAAuB,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC;QACtG,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,cAAc,CAAC,UAA0B;QAC5C,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,SAAS,CAAC,UAAU,GAAG,UAAU,CAAC;QACvC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,aAAa,CAAC,SAAiB;QAClC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,SAAS,CAAC,SAAS,GAAG,SAAS,CAAC;QACrC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,cAAc,CAAC,UAAkB;QACpC,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,UAAU,CAAC;QACnC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,aAAa,CAAC,SAA4B;QAC7C,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,SAAS,CAAC;QACjC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,SAAS,CAAC,KAAa;QAC1B,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC1B,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QAC3B,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,eAAe,CAAC,OAAsB;QACzC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE;YACzB,IAAI,CAAC,KAAK,CAAC,WAAW,GAAG,EAAE,CAAC;SAC/B;QACD,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,iBAAiB,CAAC,OAA6B;QAClD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE;YAC3B,IAAI,CAAC,KAAK,CAAC,aAAa,GAAG,EAAE,CAAC;SACjC;QACD,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACvC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,YAAY,CAAC,OAAuB,EAAE,IAAY;QACrD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE;YACrB,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,EAAE,CAAC;SAC3B;QACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC;QACnC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,YAAY,CAAC,QAAyC;QACzD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE;YACvB,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,EAAE,CAAC;SAC7B;QACD,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACpC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,QAAQ,CAAC,IAAsB;QAClC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YAClB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;SAC1B;QACD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,mBAAmB,CAAC,QAAyB;QAChD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,YAAY,CAAC,IAAa,EAAE,KAAc,EAAE,UAA0B,EAAE,UAAU,GAAG,KAAK;QAC7F,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC;QAC7D,IAAI,UAAU,IAAI,KAAK,EAAE;YACrB,IAAI,CAAC,cAAc,CAAC;gBAChB,KAAK,EAAE,KAAK;aACf,CAAC,CAAC;SACN;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;;;OAMG;IACI,iBAAiB,CAAC,KAAa,EAAE,IAAa,EAAE,UAA0B,EAAE,kBAAkB,GAAG,KAAK;QACzG,IAAI,kBAAkB,EAAE;YACpB,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC;SACjF;aAAM;YACH,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC;SAC5E;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;;OAIG;IACI,wBAAwB,CAAC,QAAyB,EAAE,kBAAkB,GAAG,KAAK;QACjF,IAAI,kBAAkB,EAAE;YACpB,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;SAC7C;aAAM;YACH,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;SACxC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,wBAAwB;QAC3B,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAChB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;SACtB;QACD,IAAI,CAAC,QAAQ,CAAC,YAAY,GAAG,IAAI,CAAC;QAClC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,eAAe,CAAC,WAAyB;QAC5C,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,IAAI,CAAC,eAAe,CAAC,eAAe,CAAC,CAAC;QACtC,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,QAAQ,CAAC,IAAY,EAAE,SAAoB;QAC9C,MAAM,iBAAiB,GAAG,YAAY,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAC/D,IAAI,CAAC,eAAe,CAAC,iBAAiB,CAAC,CAAC;QACxC,OAAO,iBAAiB,CAAC;IAC7B,CAAC;IAEM,eAAe,CAAC,OAAqB;QACxC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACzB,IAAI,IAAI,CAAC,IAAI,EAAE;YACX,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SAC/B;QACD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC5B,OAAO,IAAI,CAAC;IAChB,CAAC;IAEM,QAAQ;QACX,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YACd,MAAM,IAAI,oBAAoB,CAAC,0BAA0B,EAAE,EAAC,IAAI,EAAE,oBAAoB,EAAC,CAAC,CAAC;SAC5F;QACD,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAEM,MAAM;QACT,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;YACZ,MAAM,IAAI,oBAAoB,CAAC,wBAAwB,EAAE,EAAC,IAAI,EAAE,mBAAmB,EAAC,CAAC,CAAC;SACzF;QACD,OAAO,IAAI,CAAC,IAAI,CAAC;IACrB,CAAC;IAEM,MAAM;QACT,OAAO,IAAI,CAAC,MAAM,EAAE,CAAC;IACzB,CAAC;IAEM,KAAK;QACR,MAAM,YAAY,GAAU;YACxB,GAAG,IAAI,CAAC,KAAK;SAChB,CAAC;QAEF,IAAI,YAAY,CAAC,IAAI,EAAE;YACnB,YAAY,CAAC,IAAI,GAAG;gBAChB,GAAG,YAAY,CAAC,IAAI;gBACpB,GAAG,IAAI,CAAC,SAAS;aACpB,CAAC;SACL;aAAM;YACH,YAAY,CAAC,IAAI,GAAG,EAAC,GAAG,IAAI,CAAC,SAAS,EAAC,CAAC;SAC3C;QAED,kDAAkD;QAClD,IAAI,IAAI,CAAC,WAAW,IAAI,CAAE,YAAY,CAAC,IAAyB,CAAC,WAAW,EAAE;YACzE,YAAY,CAAC,IAAyB,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;SAC1E;QAED,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QAC9B,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;YAChB,YAAY,CAAC,IAAyB,CAAC,SAAS,GAAG,IAAI,CAAC;SAC5D;QAED,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;YACpE,qBAAqB;YACrB,YAAY,CAAC,QAAQ,GAAG,EAAE,CAAC;YAC3B,IAAI,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE;gBAC7B,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;aACtD;YACD,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE;gBACtB,KAAK,MAAM,UAAU,IAAI,IAAI,CAAC,QAAQ,EAAE;oBACpC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC,CAAC;iBAClD;aACJ;SACJ;QAED,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE;YACxB,YAAY,CAAC,WAAW,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;SAC1D;QACD,IAAI,IAAI,CAAC,KAAK,CAAC,gBAAgB,EAAE;YAC7B,YAAY,CAAC,gBAAgB,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;SACpE;QACD,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE;YACpB,YAAY,CAAC,OAAO,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;SAClD;QACD,IAAI,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE;YAC1B,YAAY,CAAC,aAAa,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;SAC9D;QACD,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE;YACpB,YAAY,CAAC,OAAO,GAAG,EAAC,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,EAAC,CAAC;SAClD;QAED,OAAO,YAAY,CAAC;IACxB,CAAC;IAEO,SAAS;QACb,MAAM,aAAa,GAA2B,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAC,GAAG,IAAI,CAAC,QAAQ,EAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACxF,MAAM,sBAAsB,GAA2B,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC;QACzG,MAAM,gBAAgB,GAA2B,EAAE,CAAC;QACpD,MAAM,qBAAqB,GAA2B,EAAE,CAAC;QAEzD,IAAI,aAAa,EAAE,KAAK,EAAE;YACtB,qBAAqB,CAAC,IAAI,CAAC,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;SACtD;QAED,MAAM,oBAAoB,GAAG,CAAC,KAAsB,EAAmB,EAAE;YACrE,MAAM,UAAU,GAAoB,EAAC,GAAG,KAAK,EAAC,CAAC;YAC/C,IAAI,OAAO,UAAU,CAAC,UAAU,KAAK,WAAW,EAAE;gBAC9C,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC;aAC1C;YACD,IAAI,OAAO,UAAU,CAAC,UAAU,KAAK,QAAQ,EAAE;gBAC3C,UAAU,CAAC,UAAU,GAAG,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;aACnD;YACD,IAAI,UAAU,CAAC,UAAU,EAAE;gBACvB,UAAU,CAAC,UAAU,GAAG,SAAS,CAAC,uBAAuB,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;aACpF;YACD,OAAO,UAAU,CAAC;QACtB,CAAC,CAAC;QAEF,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAE3F,MAAM,0BAA0B,GAA2B,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CAAC;QAEhI,qBAAqB,CAAC,IAAI,CAAC,GAAG,gBAAgB,EAAE,GAAG,sBAAsB,EAAE,GAAG,0BAA0B,CAAC,CAAC;QAE1G,IAAI,CAAC,aAAa,EAAE;YAChB,OAAO,qBAAqB,CAAC;SAChC;QAED,aAAa,CAAC,KAAK,GAAG,aAAa,CAAC,KAAK,IAAI,IAAI,CAAC,SAAS,CAAC;QAC5D,IAAI,OAAO,aAAa,CAAC,UAAU,KAAK,QAAQ,EAAE;YAC9C,aAAa,CAAC,UAAU,GAAG,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;SACzD;QACD,aAAa,CAAC,UAAU,GAAG,SAAS,CAAC,uBAAuB,CAAC,aAAa,CAAC,UAAU,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC;QACzG,IAAI,qBAAqB,CAAC,MAAM,GAAG,CAAC,EAAE;YAClC,aAAa,CAAC,KAAK,GAAG,qBAAqB,CAAC;SAC/C;QAED,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE;YACvB,MAAM,MAAM,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;YACzC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;gBACnB,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC;aACjC;SACJ;QAED,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE;YAC5B,aAAa,CAAC,WAAW,GAAG,IAAI,CAAC,uBAAuB,EAAE,CAAC;SAC9D;QAED,OAAO,CAAC,aAAa,CAAC,CAAC;IAC3B,CAAC;IAEO,cAAc,CAAC,IAAa,EAAE,KAAc,EAAE,UAA0B;QAC5E,MAAM,QAAQ,GAAoB,EAAE,CAAC;QACrC,IAAI,IAAI,EAAE;YACN,QAAQ,CAAC,IAAI,GAAG,IAAI,CAAC;SACxB;QACD,IAAI,KAAK,EAAE;YACP,QAAQ,CAAC,KAAK,GAAG,KAAK,CAAC;SAC1B;QACD,IAAI,UAAU,EAAE;YACZ,QAAQ,CAAC,UAAU,GAAG,UAAU,CAAC;SACpC;QACD,OAAO,QAAQ,CAAC;IACpB,CAAC;IAEO,kBAAkB;QACtB,MAAM,MAAM,GAAe,EAAE,CAAC;QAC9B,IAAI,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,MAAM,EAAE;YAChC,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;SAC1C;QACD,IAAI,IAAI,CAAC,MAAM,EAAE;YACb,iFAAiF;YACjF,2GAA2G;YAC3G,gDAAgD;YAChD,IAAI,CAAC,MAAM,CAAC,kBAAkB,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;gBACzC,IAAI,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE;oBACvB,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;iBAClB;YACL,CAAC,CAAC,CAAC;SACN;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;IAES,uBAAuB;QAC7B,IAAI,IAAI,CAAC,QAAQ,EAAE,WAAW,EAAE;YAC5B,OAAO,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;SACpC;QACD,IAAI,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE;YAC5B,wBAAwB;YACxB,OAAO,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC;SACrC;QACD,IAAI,IAAI,CAAC,WAAW,EAAE;YAClB,OAAO,IAAI,CAAC,WAAW,CAAC;SAC3B;QACD,OAAO,SAAS,CAAC;IACrB,CAAC;CACJ","sourcesContent":["import {EnvironmentProviders, Provider, Type} from '@angular/core';\nimport {CanActivateFn, CanDeactivateFn, DefaultExport, LoadChildren, ResolveFn, Route} from '@angular/router';\n\nimport {Observable} from 'rxjs';\n\nimport {CommonsInternalError} from '../error/error.model';\nimport {CommonsMenuItem} from '../models/menu.model';\nimport {permissionGuard} from '../security/permission.guard';\nimport {APermissions} from '../security/permissions.model';\nimport {RouteUtil} from '../utils/route.util';\nimport {BreadcrumbType, CommonsRouteData} from './router.model';\nimport {RoutesBuilder} from './routes-builder';\n\nexport class RouteBuilder {\n    protected readonly route: Route;\n    private routePath: Array<string> = [];\n    protected routeData: CommonsRouteData = {breadcrumb: null};\n    private root?: RoutesBuilder;\n    private parent?: RouteBuilder;\n    private children: Array<RouteBuilder> = [];\n\n    private menuItem?: CommonsMenuItem;\n    private menuItemChildren: Array<CommonsMenuItem> = [];\n    private menuItemChildrenAfter: Array<CommonsMenuItem> = []; // append after route children\n\n    private breadcrumb?: BreadcrumbType;\n    private pageTitle?: string;\n\n    private permissions?: APermissions;\n\n    protected constructor(route: Route) {\n        this.route = route;\n        if (this.route.path && this.route.path.length > 0) {\n            this.routePath = [this.route.path];\n        }\n    }\n\n    public static create(path: string, component: Type<any>): RouteBuilder {\n        return new RouteBuilder({\n            path: path,\n            component: component\n        });\n    }\n\n    public static createRedirect(path: string, redirectTo: string, pathMatch: 'full' | 'prefix' = 'prefix'): RouteBuilder {\n        return new RouteBuilder({\n            path: path,\n            redirectTo: redirectTo,\n            pathMatch: pathMatch\n        });\n    }\n\n    public static createLazyRouteModule(path: string, loadChildren: LoadChildren, canMatch?: Array<any>): RouteBuilder {\n        const route: Route = {path: path, loadChildren: loadChildren};\n        if (canMatch?.length) {\n            route.canMatch = canMatch;\n        }\n        return new RouteBuilder(route);\n    }\n\n    public static createLazyRouteComponent(\n        path: string,\n        loadComponent: () => Type<unknown> | Observable<Type<unknown> | DefaultExport<Type<unknown>>> | Promise<Type<unknown> | DefaultExport<Type<unknown>>>,\n        canMatch?: Array<any>\n    ): RouteBuilder {\n        const route: Route = {path: path, loadComponent: loadComponent};\n        if (canMatch?.length) {\n            route.canMatch = canMatch;\n        }\n        return new RouteBuilder(route);\n    }\n\n    public static createFromRoute(route: Route): RouteBuilder {\n        return new RouteBuilder(route);\n    }\n\n    public withRoot(routesBuilder: RoutesBuilder): this {\n        this.root = routesBuilder;\n        return this;\n    }\n\n    public withParent(parent: RouteBuilder): this {\n        this.parent = parent;\n        this.routePath = RouteUtil.removeEmptyPathSegments([...this.parent.routePath, this.route.path ?? '']);\n        return this;\n    }\n\n    public withBreadcrumb(breadcrumb: BreadcrumbType): this {\n        this.breadcrumb = breadcrumb;\n        this.routeData.breadcrumb = breadcrumb;\n        return this;\n    }\n\n    public withPageTitle(pageTitle: string): this {\n        this.pageTitle = pageTitle;\n        this.routeData.pageTitle = pageTitle;\n        return this;\n    }\n\n    public withRedirectTo(redirectTo: string): this {\n        this.route.redirectTo = redirectTo;\n        return this;\n    }\n\n    public withPathMatch(pathMatch: 'full' | 'prefix'): this {\n        this.route.pathMatch = pathMatch;\n        return this;\n    }\n\n    public withTitle(title: string): this {\n        this.withPageTitle(title);\n        this.withBreadcrumb(title);\n        return this;\n    }\n\n    public withCanActivate(diToken: CanActivateFn): this {\n        if (!this.route.canActivate) {\n            this.route.canActivate = [];\n        }\n        this.route.canActivate.push(diToken);\n        return this;\n    }\n\n    public withCanDeactivate(diToken: CanDeactivateFn<any>): this {\n        if (!this.route.canDeactivate) {\n            this.route.canDeactivate = [];\n        }\n        this.route.canDeactivate.push(diToken);\n        return this;\n    }\n\n    public withResolver(diToken: ResolveFn<any>, name: string): this {\n        if (!this.route.resolve) {\n            this.route.resolve = {};\n        }\n        this.route.resolve[name] = diToken;\n        return this;\n    }\n\n    public withProvider(provider: Provider | EnvironmentProviders): this {\n        if (!this.route.providers) {\n            this.route.providers = [];\n        }\n        this.route.providers.push(provider);\n        return this;\n    }\n\n    public withData(data: CommonsRouteData): this {\n        if (!data.breadcrumb) {\n            data.breadcrumb = null;\n        }\n        this.routeData = data;\n        return this;\n    }\n\n    public withCommonsMenuItem(menuItem: CommonsMenuItem): this {\n        this.menuItem = menuItem;\n        return this;\n    }\n\n    public withMenuItem(icon?: string, label?: string, routerLink?: Array<string>, breadcrumb = false): this {\n        this.menuItem = this.createMenuItem(icon, label, routerLink);\n        if (breadcrumb && label) {\n            this.withBreadcrumb({\n                label: label\n            });\n        }\n        return this;\n    }\n\n    /**\n     * Adds menu item child to this instance of menu item.\n     * @param label Label.\n     * @param icon Icon.\n     * @param routerLink Router link.\n     * @param afterRouteChildren If false, menu item child will be appended before route children menu items, at the end otherwise.\n     */\n    public withMenuItemChild(label: string, icon?: string, routerLink?: Array<string>, afterRouteChildren = false): this {\n        if (afterRouteChildren) {\n            this.menuItemChildrenAfter.push(this.createMenuItem(icon, label, routerLink));\n        } else {\n            this.menuItemChildren.push(this.createMenuItem(icon, label, routerLink));\n        }\n        return this;\n    }\n\n    /**\n     * Adds menu item child to this instance of menu item.\n     * @param menuItem Configuration object for menu item.\n     * @param afterRouteChildren If false, menu item child will be appended before route children menu items, at the end otherwise.\n     */\n    public withCommonsMenuItemChild(menuItem: CommonsMenuItem, afterRouteChildren = false): this {\n        if (afterRouteChildren) {\n            this.menuItemChildrenAfter.push(menuItem);\n        } else {\n            this.menuItemChildren.push(menuItem);\n        }\n        return this;\n    }\n\n    public withMenuItemLazyChildren(): this {\n        if (!this.menuItem) {\n            this.menuItem = {};\n        }\n        this.menuItem.lazyChildren = true;\n        return this;\n    }\n\n    public withPermissions(permissions: APermissions): this {\n        this.permissions = permissions;\n        this.withCanActivate(permissionGuard);\n        return this;\n    }\n\n    public addChild(path: string, component: Type<any>): RouteBuilder {\n        const childRouteBuilder = RouteBuilder.create(path, component);\n        this.addChildBuilder(childRouteBuilder);\n        return childRouteBuilder;\n    }\n\n    public addChildBuilder(builder: RouteBuilder): this {\n        builder.withParent(this);\n        if (this.root) {\n            builder.withRoot(this.root);\n        }\n        this.children.push(builder);\n        return this;\n    }\n\n    public toParent(): RouteBuilder {\n        if (!this.parent) {\n            throw new CommonsInternalError('Parent was not provided.', {name: 'RouteBuilder error'});\n        }\n        return this.parent;\n    }\n\n    public toRoot(): RoutesBuilder {\n        if (!this.root) {\n            throw new CommonsInternalError('Root was not provided.', {name: 'RouteBuilderError'});\n        }\n        return this.root;\n    }\n\n    public finish(): RoutesBuilder {\n        return this.toRoot();\n    }\n\n    public build(): Route {\n        const angularRoute: Route = {\n            ...this.route\n        };\n\n        if (angularRoute.data) {\n            angularRoute.data = {\n                ...angularRoute.data,\n                ...this.routeData\n            };\n        } else {\n            angularRoute.data = {...this.routeData};\n        }\n\n        // append permissions if not already in route data\n        if (this.permissions && !(angularRoute.data as CommonsRouteData).permissions) {\n            (angularRoute.data as CommonsRouteData).permissions = this.permissions;\n        }\n\n        const menu = this.buildMenu();\n        if (menu.length > 0) {\n            (angularRoute.data as CommonsRouteData).menuItems = menu;\n        }\n\n        if ((this.route.children?.length ?? 0) > 0 || this.children.length > 0) {\n            // route has children\n            angularRoute.children = [];\n            if (this.route.children?.length) {\n                angularRoute.children.push(...this.route.children);\n            }\n            if (this.children.length) {\n                for (const childRoute of this.children) {\n                    angularRoute.children.push(childRoute.build());\n                }\n            }\n        }\n\n        if (this.route.canActivate) {\n            angularRoute.canActivate = [...this.route.canActivate];\n        }\n        if (this.route.canActivateChild) {\n            angularRoute.canActivateChild = [...this.route.canActivateChild];\n        }\n        if (this.route.canLoad) {\n            angularRoute.canLoad = [...this.route.canLoad];\n        }\n        if (this.route.canDeactivate) {\n            angularRoute.canDeactivate = [...this.route.canDeactivate];\n        }\n        if (this.route.resolve) {\n            angularRoute.resolve = {...this.route.resolve};\n        }\n\n        return angularRoute;\n    }\n\n    private buildMenu(): Array<CommonsMenuItem> {\n        const menuItemBuild: CommonsMenuItem | null = this.menuItem ? {...this.menuItem} : null;\n        const routeChildrenMenuItems: Array<CommonsMenuItem> = this.children.flatMap(child => child.buildMenu());\n        const menuItemChildren: Array<CommonsMenuItem> = [];\n        const menuItemChildrenBuild: Array<CommonsMenuItem> = [];\n\n        if (menuItemBuild?.items) {\n            menuItemChildrenBuild.push(...menuItemBuild.items);\n        }\n\n        const processMenuItemChild = (child: CommonsMenuItem): CommonsMenuItem => {\n            const finalChild: CommonsMenuItem = {...child};\n            if (typeof finalChild.routerLink === 'undefined') {\n                finalChild.routerLink = this.routePath;\n            }\n            if (typeof finalChild.routerLink === 'string') {\n                finalChild.routerLink = [finalChild.routerLink];\n            }\n            if (finalChild.routerLink) {\n                finalChild.routerLink = RouteUtil.removeEmptyPathSegments(finalChild.routerLink);\n            }\n            return finalChild;\n        };\n\n        this.menuItemChildren.forEach(child => menuItemChildren.push(processMenuItemChild(child)));\n\n        const menuItemChildrenAfterBuild: Array<CommonsMenuItem> = this.menuItemChildrenAfter.map(child => processMenuItemChild(child));\n\n        menuItemChildrenBuild.push(...menuItemChildren, ...routeChildrenMenuItems, ...menuItemChildrenAfterBuild);\n\n        if (!menuItemBuild) {\n            return menuItemChildrenBuild;\n        }\n\n        menuItemBuild.label = menuItemBuild.label ?? this.pageTitle;\n        if (typeof menuItemBuild.routerLink === 'string') {\n            menuItemBuild.routerLink = [menuItemBuild.routerLink];\n        }\n        menuItemBuild.routerLink = RouteUtil.removeEmptyPathSegments(menuItemBuild.routerLink ?? this.routePath);\n        if (menuItemChildrenBuild.length > 0) {\n            menuItemBuild.items = menuItemChildrenBuild;\n        }\n\n        if (!menuItemBuild.guards) {\n            const guards = this.findMenuItemGuards();\n            if (guards.length > 0) {\n                menuItemBuild.guards = guards;\n            }\n        }\n\n        if (!menuItemBuild.permissions) {\n            menuItemBuild.permissions = this.findMenuItemPermissions();\n        }\n\n        return [menuItemBuild];\n    }\n\n    private createMenuItem(icon?: string, label?: string, routerLink?: Array<string>) {\n        const menuItem: CommonsMenuItem = {};\n        if (icon) {\n            menuItem.icon = icon;\n        }\n        if (label) {\n            menuItem.label = label;\n        }\n        if (routerLink) {\n            menuItem.routerLink = routerLink;\n        }\n        return menuItem;\n    }\n\n    private findMenuItemGuards(): Array<any> {\n        const guards: Array<any> = [];\n        if (this.route.canActivate?.length) {\n            guards.push(...this.route.canActivate);\n        }\n        if (this.parent) {\n            // Check for parent guards that should be included in decision to hide menu item!\n            // Some parent routes might have guards, but no menu items, so this guards must be taken into account here,\n            // because there is no parent menu item to hide.\n            this.parent.findMenuItemGuards().forEach(g => {\n                if (guards.indexOf(g) < 0) {\n                    guards.push(g);\n                }\n            });\n        }\n        return guards;\n    }\n\n    protected findMenuItemPermissions() {\n        if (this.menuItem?.permissions) {\n            return this.menuItem.permissions;\n        }\n        if (this.routeData.permissions) {\n            // this is already built\n            return this.routeData.permissions;\n        }\n        if (this.permissions) {\n            return this.permissions;\n        }\n        return undefined;\n    }\n}\n"]}

package/esm2022/core/router/router.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGVyLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vY29yZS9zcmMvcm91dGVyL3JvdXRlci5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90LCBEYXRhfSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xuXG5pbXBvcnQge0NvbW1vbnNNZW51SXRlbX0gZnJvbSAnLi4vbW9kZWxzL21lbnUubW9kZWwnO1xuaW1wb3J0IHtBUGVybWlzc2lvbnN9IGZyb20gJy4uL3NlY3VyaXR5L3Blcm1pc3Npb25zLm1vZGVsJztcblxuZXhwb3J0IHR5cGUgQnJlYWRjcnVtYlR5cGUgPSBzdHJpbmcgfCBzdHJpbmdbXSB8IEJyZWFkY3J1bWJNZW51SXRlbSB8IEJyZWFkY3J1bWJNZW51SXRlbVtdIHwgKChyb3V0ZVVybDogc3RyaW5nLCByb3V0ZTogQWN0aXZhdGVkUm91dGVTbmFwc2hvdCkgPT4gQnJlYWRjcnVtYk1lbnVJdGVtW10pO1xuXG5leHBvcnQgaW50ZXJmYWNlIEJyZWFkY3J1bWJNZW51SXRlbSBleHRlbmRzIENvbW1vbnNNZW51SXRlbSB7XG4gICAgaXNIb21lPzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBDb21tb25zUm91dGVEYXRhIGV4dGVuZHMgRGF0YSB7XG4gICAgYnJlYWRjcnVtYj86IEJyZWFkY3J1bWJUeXBlIHwgbnVsbDtcbiAgICBwYWdlVGl0bGU/OiBzdHJpbmc7XG4gICAgbWVudUl0ZW1zPzogQXJyYXk8Q29tbW9uc01lbnVJdGVtPjtcbiAgICBwZXJtaXNzaW9ucz86IEFQZXJtaXNzaW9ucztcbn1cbiJdfQ==

package/esm2022/core/router/routes-builder.mjs

@@ -0,0 +1,53 @@
+import { CommonsInternalError } from '../error/error.model';
+import { RouteBuilder } from './route-builder';
+export class RoutesBuilder {
+    constructor(layoutRoute) {
+        this.routes = [];
+        this.layoutRoute = layoutRoute?.withRoot(this);
+        this.currentRoute = layoutRoute;
+    }
+    static create() {
+        return new RoutesBuilder();
+    }
+    addAngularRoute(route) {
+        return this.addRouteBuilder(RouteBuilder.createFromRoute(route));
+    }
+    addRouteRedirect(path, redirectTo, pathMatch = 'prefix') {
+        return this.addRouteBuilder(RouteBuilder.createRedirect(path, redirectTo, pathMatch));
+    }
+    addLazyRouteComponent(path, loadComponent, canMatch) {
+        return this.addRouteBuilder(RouteBuilder.createLazyRouteComponent(path, loadComponent, canMatch));
+    }
+    addLazyRouteModule(path, loadChildren, canMatch) {
+        return this.addRouteBuilder(RouteBuilder.createLazyRouteModule(path, loadChildren, canMatch));
+    }
+    addRoute(path, component) {
+        return this.addRouteBuilder(RouteBuilder.create(path, component));
+    }
+    addRouteBuilder(routeBuilder) {
+        this.currentRoute = routeBuilder.withRoot(this);
+        this.routes.push(routeBuilder);
+        return this;
+    }
+    toRoute() {
+        if (!this.currentRoute) {
+            throw new CommonsInternalError('No routes were added!', { name: 'RoutesBuilderError' });
+        }
+        return this.currentRoute;
+    }
+    build() {
+        let angularRoutes = [];
+        for (const route of this.routes) {
+            angularRoutes.push(route.build());
+        }
+        if (this.layoutRoute) {
+            const layoutAngularRoute = this.layoutRoute.build();
+            if (angularRoutes.length > 0) {
+                layoutAngularRoute.children = angularRoutes;
+            }
+            angularRoutes = [layoutAngularRoute];
+        }
+        return angularRoutes;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/rxjs/map-data-list-result-operator.mjs

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+/**
+ * Maps an Observable of data with optional totalCount and data to a data list result object with provided defaults of empty array and count 0.
+ */
+export function mapToDataList() {
+    return function (source) {
+        return new Observable(subscriber => {
+            return source.subscribe({
+                next(value) {
+                    subscriber.next({
+                        data: value.data ?? [],
+                        totalCount: value.totalCount ?? value.data?.length ?? 0
+                    });
+                }
+            });
+        });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFwLWRhdGEtbGlzdC1yZXN1bHQtb3BlcmF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9jb3JlL3NyYy9yeGpzL21hcC1kYXRhLWxpc3QtcmVzdWx0LW9wZXJhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxVQUFVLEVBQW1CLE1BQU0sTUFBTSxDQUFDO0FBSWxEOztHQUVHO0FBQ0gsTUFBTSxVQUFVLGFBQWE7SUFDekIsT0FBTyxVQUFnQixNQUF3RDtRQUMzRSxPQUFPLElBQUksVUFBVSxDQUFDLFVBQVUsQ0FBQyxFQUFFO1lBQy9CLE9BQU8sTUFBTSxDQUFDLFNBQVMsQ0FBQztnQkFDcEIsSUFBSSxDQUFDLEtBQUs7b0JBQ04sVUFBVSxDQUFDLElBQUksQ0FBQzt3QkFDWixJQUFJLEVBQUUsS0FBSyxDQUFDLElBQUksSUFBSSxFQUFFO3dCQUN0QixVQUFVLEVBQUUsS0FBSyxDQUFDLFVBQVUsSUFBSSxLQUFLLENBQUMsSUFBSSxFQUFFLE1BQU0sSUFBSSxDQUFDO3FCQUMxRCxDQUFDLENBQUM7Z0JBQ1AsQ0FBQzthQUNKLENBQUMsQ0FBQztRQUNQLENBQUMsQ0FBQyxDQUFDO0lBQ1AsQ0FBQyxDQUFDO0FBQ04sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7T2JzZXJ2YWJsZSwgT3BlcmF0b3JGdW5jdGlvbn0gZnJvbSAncnhqcyc7XG5cbmltcG9ydCB7RGF0YUxpc3RSZXN1bHR9IGZyb20gJy4uL2RhdGEtbGlzdC9kYXRhLWxpc3QubW9kZWwnO1xuXG4vKipcbiAqIE1hcHMgYW4gT2JzZXJ2YWJsZSBvZiBkYXRhIHdpdGggb3B0aW9uYWwgdG90YWxDb3VudCBhbmQgZGF0YSB0byBhIGRhdGEgbGlzdCByZXN1bHQgb2JqZWN0IHdpdGggcHJvdmlkZWQgZGVmYXVsdHMgb2YgZW1wdHkgYXJyYXkgYW5kIGNvdW50IDAuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBtYXBUb0RhdGFMaXN0PEl0ZW0+KCk6IE9wZXJhdG9yRnVuY3Rpb248e2RhdGE/OiBJdGVtW107IHRvdGFsQ291bnQ/OiBudW1iZXJ9LCBEYXRhTGlzdFJlc3VsdDxJdGVtPj4ge1xuICAgIHJldHVybiBmdW5jdGlvbiA8SXRlbT4oc291cmNlOiBPYnNlcnZhYmxlPHtkYXRhPzogSXRlbVtdOyB0b3RhbENvdW50PzogbnVtYmVyfT4pOiBPYnNlcnZhYmxlPERhdGFMaXN0UmVzdWx0PEl0ZW0+PiB7XG4gICAgICAgIHJldHVybiBuZXcgT2JzZXJ2YWJsZShzdWJzY3JpYmVyID0+IHtcbiAgICAgICAgICAgIHJldHVybiBzb3VyY2Uuc3Vic2NyaWJlKHtcbiAgICAgICAgICAgICAgICBuZXh0KHZhbHVlKSB7XG4gICAgICAgICAgICAgICAgICAgIHN1YnNjcmliZXIubmV4dCh7XG4gICAgICAgICAgICAgICAgICAgICAgICBkYXRhOiB2YWx1ZS5kYXRhID8/IFtdLFxuICAgICAgICAgICAgICAgICAgICAgICAgdG90YWxDb3VudDogdmFsdWUudG90YWxDb3VudCA/PyB2YWx1ZS5kYXRhPy5sZW5ndGggPz8gMFxuICAgICAgICAgICAgICAgICAgICB9KTtcbiAgICAgICAgICAgICAgICB9XG4gICAgICAgICAgICB9KTtcbiAgICAgICAgfSk7XG4gICAgfTtcbn1cbiJdfQ==

package/esm2022/core/security/permission.guard.mjs

@@ -0,0 +1,15 @@
+import { inject } from '@angular/core';
+import { of } from 'rxjs';
+import { first } from 'rxjs/operators';
+import { PermissionService } from './permission.service';
+export const permissionGuard = (route) => {
+    const permission = inject(PermissionService);
+    const data = route.data;
+    if (data.permissions) {
+        return permission.isPermitted(data.permissions).pipe(first());
+    }
+    else {
+        return of(true);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVybWlzc2lvbi5ndWFyZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2NvcmUvc3JjL3NlY3VyaXR5L3Blcm1pc3Npb24uZ3VhcmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLE1BQU0sRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUdyQyxPQUFPLEVBQWEsRUFBRSxFQUFDLE1BQU0sTUFBTSxDQUFDO0FBQ3BDLE9BQU8sRUFBQyxLQUFLLEVBQUMsTUFBTSxnQkFBZ0IsQ0FBQztBQUdyQyxPQUFPLEVBQUMsaUJBQWlCLEVBQUMsTUFBTSxzQkFBc0IsQ0FBQztBQUV2RCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQWtCLENBQUMsS0FBNkIsRUFBa0YsRUFBRTtJQUM1SixNQUFNLFVBQVUsR0FBRyxNQUFNLENBQUMsaUJBQWlCLENBQUMsQ0FBQztJQUU3QyxNQUFNLElBQUksR0FBRyxLQUFLLENBQUMsSUFBd0IsQ0FBQztJQUU1QyxJQUFJLElBQUksQ0FBQyxXQUFXLEVBQUU7UUFDbEIsT0FBTyxVQUFVLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQyxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQztLQUNqRTtTQUFNO1FBQ0gsT0FBTyxFQUFFLENBQUMsSUFBSSxDQUFDLENBQUM7S0FDbkI7QUFDTCxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge2luamVjdH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0FjdGl2YXRlZFJvdXRlU25hcHNob3QsIENhbkFjdGl2YXRlRm4sIFVybFRyZWV9IGZyb20gJ0Bhbmd1bGFyL3JvdXRlcic7XG5cbmltcG9ydCB7T2JzZXJ2YWJsZSwgb2Z9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHtmaXJzdH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xuXG5pbXBvcnQge0NvbW1vbnNSb3V0ZURhdGF9IGZyb20gJy4uL3JvdXRlci9yb3V0ZXIubW9kZWwnO1xuaW1wb3J0IHtQZXJtaXNzaW9uU2VydmljZX0gZnJvbSAnLi9wZXJtaXNzaW9uLnNlcnZpY2UnO1xuXG5leHBvcnQgY29uc3QgcGVybWlzc2lvbkd1YXJkOiBDYW5BY3RpdmF0ZUZuID0gKHJvdXRlOiBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90KTogT2JzZXJ2YWJsZTxib29sZWFuIHwgVXJsVHJlZT4gfCBQcm9taXNlPGJvb2xlYW4gfCBVcmxUcmVlPiB8IGJvb2xlYW4gfCBVcmxUcmVlID0+IHtcbiAgICBjb25zdCBwZXJtaXNzaW9uID0gaW5qZWN0KFBlcm1pc3Npb25TZXJ2aWNlKTtcblxuICAgIGNvbnN0IGRhdGEgPSByb3V0ZS5kYXRhIGFzIENvbW1vbnNSb3V0ZURhdGE7XG5cbiAgICBpZiAoZGF0YS5wZXJtaXNzaW9ucykge1xuICAgICAgICByZXR1cm4gcGVybWlzc2lvbi5pc1Blcm1pdHRlZChkYXRhLnBlcm1pc3Npb25zKS5waXBlKGZpcnN0KCkpO1xuICAgIH0gZWxzZSB7XG4gICAgICAgIHJldHVybiBvZih0cnVlKTtcbiAgICB9XG59O1xuIl19

package/esm2022/core/security/permission.service.mjs

@@ -0,0 +1,49 @@
+import { Injectable, Injector, inject } from '@angular/core';
+import { Router } from '@angular/router';
+import { combineLatest, of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { LoggerService } from '../log/logger.service';
+import { CommonsService } from '../services/commons.service';
+import { PermissionUtil } from './permission.util';
+import { PermissionTypeEnum } from './permissions.model';
+import * as i0 from "@angular/core";
+export class PermissionService {
+    constructor() {
+        this.router = inject(Router);
+        this.injector = inject(Injector);
+        this.commons = inject(CommonsService);
+        this.logger = inject(LoggerService).create('AuthorizationService');
+    }
+    isPermitted(permissions, route, actionCtx) {
+        switch (permissions.authorizationType) {
+            case PermissionTypeEnum.All:
+                return this.isPermittedAll(permissions, route, actionCtx);
+            case PermissionTypeEnum.Any:
+                return this.isPermittedAny(permissions, route, actionCtx);
+            case PermissionTypeEnum.Service:
+                return this.isPermittedService(permissions, route, actionCtx);
+            default:
+                return this.commons.userRoles$.pipe(map(ur => PermissionUtil.isPermitted(permissions, ur)));
+        }
+    }
+    isPermittedAll(permission, route, actionCtx) {
+        return combineLatest(permission.permissions.map(p => this.isPermitted(p, route, actionCtx))).pipe(map(res => res.every(ip => ip === true)));
+    }
+    isPermittedAny(permission, route, actionCtx) {
+        return combineLatest(permission.permissions.map(p => this.isPermitted(p, route, actionCtx))).pipe(map(res => res.some(ip => ip === true)));
+    }
+    isPermittedService(permission, route, actionCtx) {
+        const serviceInstance = this.injector.get(permission.service);
+        if (!serviceInstance) {
+            this.logger.debug(`WARNING: Service instance could not be retreived for type ${permission.service}`);
+            return of(false);
+        }
+        return serviceInstance.isPermitted(route, this.router.routerState.snapshot, actionCtx);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: PermissionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: PermissionService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.1", ngImport: i0, type: PermissionService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/security/permission.util.mjs

@@ -0,0 +1,16 @@
+import { CommonsInternalError } from '../error/error.model';
+import { PermissionTypeEnum } from './permissions.model';
+export class PermissionUtil {
+    static isPermitted(permissions, userRoles) {
+        switch (permissions.authorizationType) {
+            case PermissionTypeEnum.Rbac:
+                return PermissionUtil.isRbacPermitted(permissions, userRoles);
+            default:
+                throw new CommonsInternalError(`Permission type "${permissions.authorizationType}" not implemented`);
+        }
+    }
+    static isRbacPermitted(permissions, userRoles) {
+        return permissions.roles.some(prg => prg.every(pr => userRoles.indexOf(pr) > -1));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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