@mediusinc/mng-commons 5.0.0-rc.0-c31d5206 → 5.0.0-rc.1

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

@@ -0,0 +1,320 @@
+import { removeRouteEmptyPathSegments } from '../helpers/route';
+import { permissionGuard } from '../security/permission.guard';
+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 = removeRouteEmptyPathSegments([...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, adjustFn) {
+        const childRouteBuilder = RouteBuilder.create(path, component);
+        adjustFn?.(childRouteBuilder);
+        return this.addChildBuilder(childRouteBuilder);
+    }
+    addChildBuilder(builder) {
+        builder.withParent(this);
+        if (this.root) {
+            builder.withRoot(this.root);
+        }
+        this.children.push(builder);
+        return this;
+    }
+    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 = removeRouteEmptyPathSegments(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 = removeRouteEmptyPathSegments(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":"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","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 {removeRouteEmptyPathSegments} from '../helpers/route';\nimport {CommonsMenuItem} from '../models/menu.model';\nimport {permissionGuard} from '../security/permission.guard';\nimport {APermissions} from '../security/permissions.model';\nimport {BreadcrumbType, CommonsRouteData} from './router.model';\nimport {RoutesBuilder} from './routes-builder';\n\nexport type RouteBuilderAdjustFnType = (builder: RouteBuilder) => void;\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 = removeRouteEmptyPathSegments([...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>, adjustFn?: RouteBuilderAdjustFnType): this {\n        const childRouteBuilder = RouteBuilder.create(path, component);\n        adjustFn?.(childRouteBuilder);\n        return this.addChildBuilder(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 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 = removeRouteEmptyPathSegments(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 = removeRouteEmptyPathSegments(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,54 @@
+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, builderAdjustFn) {
+        const builder = RouteBuilder.createFromRoute(route);
+        builderAdjustFn?.(builder);
+        return this.addRouteBuilder(builder);
+    }
+    addRouteRedirect(path, redirectTo, pathMatch = 'prefix') {
+        return this.addRouteBuilder(RouteBuilder.createRedirect(path, redirectTo, pathMatch));
+    }
+    addLazyRouteComponent(path, loadComponent, canMatch, builderAdjustFn) {
+        const builder = RouteBuilder.createLazyRouteComponent(path, loadComponent, canMatch);
+        builderAdjustFn?.(builder);
+        return this.addRouteBuilder(builder);
+    }
+    addLazyRouteModule(path, loadChildren, canMatch, builderAdjustFn) {
+        const builder = RouteBuilder.createLazyRouteModule(path, loadChildren, canMatch);
+        builderAdjustFn?.(builder);
+        return this.addRouteBuilder(builder);
+    }
+    addRoute(path, component, builderAdjustFn) {
+        const builder = RouteBuilder.create(path, component);
+        builderAdjustFn?.(builder);
+        return this.addRouteBuilder(builder);
+    }
+    addRouteBuilder(routeBuilder) {
+        this.currentRoute = routeBuilder.withRoot(this);
+        this.routes.push(routeBuilder);
+        return this;
+    }
+    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-helpers.mjs

@@ -0,0 +1,14 @@
+import { CommonsInternalError } from '../error/error.model';
+import { PermissionTypeEnum } from './permissions.model';
+export function isPermitted(permissions, userRoles) {
+    switch (permissions.authorizationType) {
+        case PermissionTypeEnum.Rbac:
+            return isRbacPermitted(permissions, userRoles);
+        default:
+            throw new CommonsInternalError(`Permission type "${permissions.authorizationType}" not implemented`);
+    }
+}
+export function isRbacPermitted(permissions, userRoles) {
+    return permissions.roles.some(prg => prg.every(pr => userRoles.indexOf(pr) > -1));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVybWlzc2lvbi1oZWxwZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vY29yZS9zcmMvc2VjdXJpdHkvcGVybWlzc2lvbi1oZWxwZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxvQkFBb0IsRUFBQyxNQUFNLHNCQUFzQixDQUFDO0FBQzFELE9BQU8sRUFBZSxrQkFBa0IsRUFBYyxNQUFNLHFCQUFxQixDQUFDO0FBRWxGLE1BQU0sVUFBVSxXQUFXLENBQUMsV0FBeUIsRUFBRSxTQUF3QjtJQUMzRSxRQUFRLFdBQVcsQ0FBQyxpQkFBaUIsRUFBRSxDQUFDO1FBQ3BDLEtBQUssa0JBQWtCLENBQUMsSUFBSTtZQUN4QixPQUFPLGVBQWUsQ0FBQyxXQUFnQyxFQUFFLFNBQVMsQ0FBQyxDQUFDO1FBQ3hFO1lBQ0ksTUFBTSxJQUFJLG9CQUFvQixDQUFDLG9CQUFvQixXQUFXLENBQUMsaUJBQWlCLG1CQUFtQixDQUFDLENBQUM7SUFDN0csQ0FBQztBQUNMLENBQUM7QUFFRCxNQUFNLFVBQVUsZUFBZSxDQUFDLFdBQThCLEVBQUUsU0FBd0I7SUFDcEYsT0FBTyxXQUFXLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUN0RixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtDb21tb25zSW50ZXJuYWxFcnJvcn0gZnJvbSAnLi4vZXJyb3IvZXJyb3IubW9kZWwnO1xuaW1wb3J0IHtBUGVybWlzc2lvbnMsIFBlcm1pc3Npb25UeXBlRW51bSwgUGVybWlzc2lvbnN9IGZyb20gJy4vcGVybWlzc2lvbnMubW9kZWwnO1xuXG5leHBvcnQgZnVuY3Rpb24gaXNQZXJtaXR0ZWQocGVybWlzc2lvbnM6IEFQZXJtaXNzaW9ucywgdXNlclJvbGVzOiBBcnJheTxzdHJpbmc+KTogYm9vbGVhbiB7XG4gICAgc3dpdGNoIChwZXJtaXNzaW9ucy5hdXRob3JpemF0aW9uVHlwZSkge1xuICAgICAgICBjYXNlIFBlcm1pc3Npb25UeXBlRW51bS5SYmFjOlxuICAgICAgICAgICAgcmV0dXJuIGlzUmJhY1Blcm1pdHRlZChwZXJtaXNzaW9ucyBhcyBQZXJtaXNzaW9ucy5Sb2xlcywgdXNlclJvbGVzKTtcbiAgICAgICAgZGVmYXVsdDpcbiAgICAgICAgICAgIHRocm93IG5ldyBDb21tb25zSW50ZXJuYWxFcnJvcihgUGVybWlzc2lvbiB0eXBlIFwiJHtwZXJtaXNzaW9ucy5hdXRob3JpemF0aW9uVHlwZX1cIiBub3QgaW1wbGVtZW50ZWRgKTtcbiAgICB9XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBpc1JiYWNQZXJtaXR0ZWQocGVybWlzc2lvbnM6IFBlcm1pc3Npb25zLlJvbGVzLCB1c2VyUm9sZXM6IEFycmF5PHN0cmluZz4pOiBib29sZWFuIHtcbiAgICByZXR1cm4gcGVybWlzc2lvbnMucm9sZXMuc29tZShwcmcgPT4gcHJnLmV2ZXJ5KHByID0+IHVzZXJSb2xlcy5pbmRleE9mKHByKSA+IC0xKSk7XG59XG4iXX0=

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVybWlzc2lvbi5ndWFyZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2NvcmUvc3JjL3NlY3VyaXR5L3Blcm1pc3Npb24uZ3VhcmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLE1BQU0sRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUdyQyxPQUFPLEVBQWEsRUFBRSxFQUFDLE1BQU0sTUFBTSxDQUFDO0FBQ3BDLE9BQU8sRUFBQyxLQUFLLEVBQUMsTUFBTSxnQkFBZ0IsQ0FBQztBQUdyQyxPQUFPLEVBQUMsaUJBQWlCLEVBQUMsTUFBTSxzQkFBc0IsQ0FBQztBQUV2RCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQWtCLENBQUMsS0FBNkIsRUFBa0YsRUFBRTtJQUM1SixNQUFNLFVBQVUsR0FBRyxNQUFNLENBQUMsaUJBQWlCLENBQUMsQ0FBQztJQUU3QyxNQUFNLElBQUksR0FBRyxLQUFLLENBQUMsSUFBd0IsQ0FBQztJQUU1QyxJQUFJLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUNuQixPQUFPLFVBQVUsQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBQ2xFLENBQUM7U0FBTSxDQUFDO1FBQ0osT0FBTyxFQUFFLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDcEIsQ0FBQztBQUNMLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7aW5qZWN0fSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7QWN0aXZhdGVkUm91dGVTbmFwc2hvdCwgQ2FuQWN0aXZhdGVGbiwgVXJsVHJlZX0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcblxuaW1wb3J0IHtPYnNlcnZhYmxlLCBvZn0gZnJvbSAncnhqcyc7XG5pbXBvcnQge2ZpcnN0fSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XG5cbmltcG9ydCB7Q29tbW9uc1JvdXRlRGF0YX0gZnJvbSAnLi4vcm91dGVyL3JvdXRlci5tb2RlbCc7XG5pbXBvcnQge1Blcm1pc3Npb25TZXJ2aWNlfSBmcm9tICcuL3Blcm1pc3Npb24uc2VydmljZSc7XG5cbmV4cG9ydCBjb25zdCBwZXJtaXNzaW9uR3VhcmQ6IENhbkFjdGl2YXRlRm4gPSAocm91dGU6IEFjdGl2YXRlZFJvdXRlU25hcHNob3QpOiBPYnNlcnZhYmxlPGJvb2xlYW4gfCBVcmxUcmVlPiB8IFByb21pc2U8Ym9vbGVhbiB8IFVybFRyZWU+IHwgYm9vbGVhbiB8IFVybFRyZWUgPT4ge1xuICAgIGNvbnN0IHBlcm1pc3Npb24gPSBpbmplY3QoUGVybWlzc2lvblNlcnZpY2UpO1xuXG4gICAgY29uc3QgZGF0YSA9IHJvdXRlLmRhdGEgYXMgQ29tbW9uc1JvdXRlRGF0YTtcblxuICAgIGlmIChkYXRhLnBlcm1pc3Npb25zKSB7XG4gICAgICAgIHJldHVybiBwZXJtaXNzaW9uLmlzUGVybWl0dGVkKGRhdGEucGVybWlzc2lvbnMpLnBpcGUoZmlyc3QoKSk7XG4gICAgfSBlbHNlIHtcbiAgICAgICAgcmV0dXJuIG9mKHRydWUpO1xuICAgIH1cbn07XG4iXX0=

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 { isPermitted } from './permission-helpers';
+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 => 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.3.2", ngImport: i0, type: PermissionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: PermissionService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.2", ngImport: i0, type: PermissionService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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