@deenruv/admin-ui 1.0.0

package/esm2022/core/providers/notification/notification.service.mjs

@@ -0,0 +1,157 @@
+import { Injectable } from '@angular/core';
+import { NotificationComponent } from '../../components/notification/notification.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../i18n/i18n.service";
+import * as i2 from "../overlay-host/overlay-host.service";
+// How many ms before the toast is dismissed.
+const TOAST_DURATION = 3000;
+/**
+ * @description
+ * Provides toast notification functionality.
+ *
+ * @example
+ * ```ts
+ * class MyComponent {
+ *   constructor(private notificationService: NotificationService) {}
+ *
+ *   save() {
+ *     this.notificationService
+ *         .success(_('asset.notify-create-assets-success'), {
+ *           count: successCount,
+ *         });
+ *   }
+ * }
+ *
+ * @docsCategory services
+ * @docsPage NotificationService
+ * @docsWeight 0
+ */
+export class NotificationService {
+    get hostView() {
+        return this.overlayHostService.getHostView();
+    }
+    constructor(i18nService, resolver, overlayHostService) {
+        this.i18nService = i18nService;
+        this.resolver = resolver;
+        this.overlayHostService = overlayHostService;
+        this.openToastRefs = [];
+    }
+    /**
+     * @description
+     * Display a success toast notification
+     */
+    success(message, translationVars) {
+        this.notify({
+            message,
+            translationVars,
+            type: 'success',
+        });
+    }
+    /**
+     * @description
+     * Display an info toast notification
+     */
+    info(message, translationVars) {
+        this.notify({
+            message,
+            translationVars,
+            type: 'info',
+        });
+    }
+    /**
+     * @description
+     * Display a warning toast notification
+     */
+    warning(message, translationVars) {
+        this.notify({
+            message,
+            translationVars,
+            type: 'warning',
+        });
+    }
+    /**
+     * @description
+     * Display an error toast notification
+     */
+    error(message, translationVars) {
+        this.notify({
+            message,
+            translationVars,
+            type: 'error',
+            duration: 20000,
+        });
+    }
+    /**
+     * @description
+     * Display a toast notification.
+     */
+    notify(config) {
+        this.createToast(config);
+    }
+    /**
+     * Load a ToastComponent into the DOM host location.
+     */
+    async createToast(config) {
+        const toastFactory = this.resolver.resolveComponentFactory(NotificationComponent);
+        const hostView = await this.hostView;
+        const ref = hostView.createComponent(toastFactory);
+        const toast = ref.instance;
+        const dismissFn = this.createDismissFunction(ref);
+        toast.type = config.type || 'info';
+        toast.message = config.message;
+        toast.translationVars = this.translateTranslationVars(config.translationVars || {});
+        toast.registerOnClickFn(dismissFn);
+        let timerId;
+        if (!config.duration || 0 < config.duration) {
+            timerId = setTimeout(dismissFn, config.duration || TOAST_DURATION);
+        }
+        this.openToastRefs.unshift({ ref, timerId });
+        setTimeout(() => this.calculatePositions());
+    }
+    /**
+     * Returns a function which will destroy the toast component and
+     * remove it from the openToastRefs array.
+     */
+    createDismissFunction(ref) {
+        return () => {
+            const toast = ref.instance;
+            const index = this.openToastRefs.map(o => o.ref).indexOf(ref);
+            if (this.openToastRefs[index]) {
+                clearTimeout(this.openToastRefs[index].timerId);
+            }
+            toast.fadeOut().then(() => {
+                ref.destroy();
+                this.openToastRefs.splice(index, 1);
+                this.calculatePositions();
+            });
+        };
+    }
+    /**
+     * Calculate and set the top offsets for each of the open toasts.
+     */
+    calculatePositions() {
+        let cumulativeHeight = 10;
+        this.openToastRefs.forEach(obj => {
+            const toast = obj.ref.instance;
+            toast.offsetTop = cumulativeHeight;
+            cumulativeHeight += toast.getHeight() + 6;
+        });
+    }
+    translateTranslationVars(translationVars) {
+        for (const [key, val] of Object.entries(translationVars)) {
+            if (typeof val === 'string') {
+                translationVars[key] = this.i18nService.translate(val);
+            }
+        }
+        return translationVars;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NotificationService, deps: [{ token: i1.I18nService }, { token: i0.ComponentFactoryResolver }, { token: i2.OverlayHostService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NotificationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NotificationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.I18nService }, { type: i0.ComponentFactoryResolver }, { type: i2.OverlayHostService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification.service.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/providers/notification/notification.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentFactoryResolver, ComponentRef, Injectable, ViewContainerRef } from '@angular/core';\n\nimport { NotificationComponent } from '../../components/notification/notification.component';\nimport { I18nService } from '../i18n/i18n.service';\nimport { OverlayHostService } from '../overlay-host/overlay-host.service';\n\n/**\n * @description\n * The types of notification available.\n *\n * @docsCategory services\n * @docsPage NotificationService\n */\nexport type NotificationType = 'info' | 'success' | 'error' | 'warning';\n\n/**\n * @description\n * Configuration for a toast notification.\n *\n * @docsCategory services\n * @docsPage NotificationService\n */\nexport interface ToastConfig {\n    message: string;\n    translationVars?: { [key: string]: string | number };\n    type?: NotificationType;\n    duration?: number;\n}\n\n// How many ms before the toast is dismissed.\nconst TOAST_DURATION = 3000;\n\n/**\n * @description\n * Provides toast notification functionality.\n *\n * @example\n * ```ts\n * class MyComponent {\n *   constructor(private notificationService: NotificationService) {}\n *\n *   save() {\n *     this.notificationService\n *         .success(_('asset.notify-create-assets-success'), {\n *           count: successCount,\n *         });\n *   }\n * }\n *\n * @docsCategory services\n * @docsPage NotificationService\n * @docsWeight 0\n */\n@Injectable({\n    providedIn: 'root',\n})\nexport class NotificationService {\n    private get hostView(): Promise<ViewContainerRef> {\n        return this.overlayHostService.getHostView();\n    }\n\n    private openToastRefs: Array<{ ref: ComponentRef<NotificationComponent>; timerId: any }> = [];\n\n    constructor(\n        private i18nService: I18nService,\n        private resolver: ComponentFactoryResolver,\n        private overlayHostService: OverlayHostService,\n    ) {}\n\n    /**\n     * @description\n     * Display a success toast notification\n     */\n    success(message: string, translationVars?: { [key: string]: string | number }): void {\n        this.notify({\n            message,\n            translationVars,\n            type: 'success',\n        });\n    }\n\n    /**\n     * @description\n     * Display an info toast notification\n     */\n    info(message: string, translationVars?: { [key: string]: string | number }): void {\n        this.notify({\n            message,\n            translationVars,\n            type: 'info',\n        });\n    }\n\n    /**\n     * @description\n     * Display a warning toast notification\n     */\n    warning(message: string, translationVars?: { [key: string]: string | number }): void {\n        this.notify({\n            message,\n            translationVars,\n            type: 'warning',\n        });\n    }\n\n    /**\n     * @description\n     * Display an error toast notification\n     */\n    error(message: string, translationVars?: { [key: string]: string | number }): void {\n        this.notify({\n            message,\n            translationVars,\n            type: 'error',\n            duration: 20000,\n        });\n    }\n\n    /**\n     * @description\n     * Display a toast notification.\n     */\n    notify(config: ToastConfig): void {\n        this.createToast(config);\n    }\n\n    /**\n     * Load a ToastComponent into the DOM host location.\n     */\n    private async createToast(config: ToastConfig): Promise<void> {\n        const toastFactory = this.resolver.resolveComponentFactory(NotificationComponent);\n        const hostView = await this.hostView;\n        const ref = hostView.createComponent<NotificationComponent>(toastFactory);\n        const toast: NotificationComponent = ref.instance;\n        const dismissFn = this.createDismissFunction(ref);\n        toast.type = config.type || 'info';\n        toast.message = config.message;\n        toast.translationVars = this.translateTranslationVars(config.translationVars || {});\n        toast.registerOnClickFn(dismissFn);\n\n        let timerId;\n        if (!config.duration || 0 < config.duration) {\n            timerId = setTimeout(dismissFn, config.duration || TOAST_DURATION);\n        }\n\n        this.openToastRefs.unshift({ ref, timerId });\n        setTimeout(() => this.calculatePositions());\n    }\n\n    /**\n     * Returns a function which will destroy the toast component and\n     * remove it from the openToastRefs array.\n     */\n    private createDismissFunction(ref: ComponentRef<NotificationComponent>): () => void {\n        return () => {\n            const toast: NotificationComponent = ref.instance;\n            const index = this.openToastRefs.map(o => o.ref).indexOf(ref);\n\n            if (this.openToastRefs[index]) {\n                clearTimeout(this.openToastRefs[index].timerId);\n            }\n\n            toast.fadeOut().then(() => {\n                ref.destroy();\n                this.openToastRefs.splice(index, 1);\n                this.calculatePositions();\n            });\n        };\n    }\n\n    /**\n     * Calculate and set the top offsets for each of the open toasts.\n     */\n    private calculatePositions(): void {\n        let cumulativeHeight = 10;\n\n        this.openToastRefs.forEach(obj => {\n            const toast: NotificationComponent = obj.ref.instance;\n            toast.offsetTop = cumulativeHeight;\n            cumulativeHeight += toast.getHeight() + 6;\n        });\n    }\n\n    private translateTranslationVars(translationVars: { [key: string]: string | number }): {\n        [key: string]: string | number;\n    } {\n        for (const [key, val] of Object.entries(translationVars)) {\n            if (typeof val === 'string') {\n                translationVars[key] = this.i18nService.translate(val);\n            }\n        }\n        return translationVars;\n    }\n}\n"]}

package/esm2022/core/providers/overlay-host/overlay-host.service.mjs

@@ -0,0 +1,48 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * The OverlayHostService is used to get a reference to the ViewConainerRef of the
+ * OverlayHost component, so that other components may insert components & elements
+ * into the DOM at that point.
+ */
+export class OverlayHostService {
+    constructor() {
+        this.promiseResolveFns = [];
+    }
+    /**
+     * Used to pass in the ViewContainerRed from the OverlayHost component.
+     * Should not be used by any other component.
+     */
+    registerHostView(viewContainerRef) {
+        this.hostView = viewContainerRef;
+        if (0 < this.promiseResolveFns.length) {
+            this.resolveHostView();
+        }
+    }
+    /**
+     * Returns a promise which resolves to the ViewContainerRef of the OverlayHost
+     * component. This can then be used to insert components and elements into the
+     * DOM at that point.
+     */
+    getHostView() {
+        return new Promise((resolve) => {
+            this.promiseResolveFns.push(resolve);
+            if (this.hostView !== undefined) {
+                this.resolveHostView();
+            }
+        });
+    }
+    resolveHostView() {
+        this.promiseResolveFns.forEach(resolve => resolve(this.hostView));
+        this.promiseResolveFns = [];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OverlayHostService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OverlayHostService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OverlayHostService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/providers/page/page.service.mjs

@@ -0,0 +1,63 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { CanDeactivateDetailGuard } from '../../shared/providers/routing/can-deactivate-detail-guard';
+import * as i0 from "@angular/core";
+export class PageService {
+    constructor() {
+        this.registry = new Map();
+    }
+    registerPageTab(config) {
+        if (!this.registry.has(config.location)) {
+            this.registry.set(config.location, []);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const pages = this.registry.get(config.location);
+        if (pages.find(p => p.tab === config.tab)) {
+            throw new Error(`A page with the tab "${config.tab}" has already been registered`);
+        }
+        pages.push(config);
+    }
+    getPageTabRoutes(location) {
+        const configs = this.registry.get(location) || [];
+        return configs.map(config => {
+            const route = {
+                path: config.route || '',
+                pathMatch: config.route ? 'prefix' : 'full',
+            };
+            let component;
+            if (isComponentWithResolver(config.component)) {
+                const { component: cmp, breadcrumbFn, resolveFn } = config.component;
+                component = cmp;
+                route.resolve = { detail: resolveFn };
+                route.data = {
+                    breadcrumb: data => data.detail.entity.pipe(map(entity => breadcrumbFn(entity))),
+                };
+            }
+            else {
+                component = config.component;
+            }
+            const guards = typeof component.prototype.canDeactivate === 'function' ? [CanDeactivateDetailGuard] : [];
+            route.component = component;
+            route.canDeactivate = guards;
+            if (config.routeConfig) {
+                Object.assign(route, config.routeConfig);
+            }
+            return route;
+        });
+    }
+    getPageTabs(location) {
+        return this.registry.get(location)?.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0)) || [];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+function isComponentWithResolver(input) {
+    return input && input.hasOwnProperty('resolveFn');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"page.service.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/providers/page/page.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Type } from '@angular/core';\nimport { Route } from '@angular/router';\nimport { map } from 'rxjs/operators';\nimport { detailComponentWithResolver } from '../../common/base-detail.component';\nimport { PageLocationId } from '../../common/component-registry-types';\nimport { CanDeactivateDetailGuard } from '../../shared/providers/routing/can-deactivate-detail-guard';\n\n/**\n * @description\n * The object used to configure a new page tab.\n *\n * @docsCategory tabs\n */\nexport interface PageTabConfig {\n    /**\n     * @description\n     * A valid location representing a list or detail page.\n     */\n    location: PageLocationId;\n    /**\n     * @description\n     * An optional icon to display in the tab. The icon\n     * should be a valid shape name from the [Clarity Icons](https://core.clarity.design/foundation/icons/shapes/)\n     * set.\n     */\n    tabIcon?: string;\n    /**\n     * @description\n     * The route path to the tab. This will be appended to the\n     * route of the parent page.\n     */\n    route: string;\n    /**\n     * @description\n     * The name of the tab to display in the UI.\n     */\n    tab: string;\n    /**\n     * @description\n     * The priority of the tab. Tabs with a lower priority will be displayed first.\n     */\n    priority?: number;\n    /**\n     * @description\n     * The component to render at the route of the tab.\n     */\n    component: Type<any> | ReturnType<typeof detailComponentWithResolver>;\n    /**\n     * @description\n     * You can optionally provide any native Angular route configuration options here.\n     * Any values provided here will take precedence over the values generated\n     * by the `route` and `component` properties.\n     */\n    routeConfig?: Route;\n}\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class PageService {\n    private registry = new Map<PageLocationId, PageTabConfig[]>();\n\n    registerPageTab(config: PageTabConfig) {\n        if (!this.registry.has(config.location)) {\n            this.registry.set(config.location, []);\n        }\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        const pages = this.registry.get(config.location)!;\n        if (pages.find(p => p.tab === config.tab)) {\n            throw new Error(`A page with the tab \"${config.tab}\" has already been registered`);\n        }\n        pages.push(config);\n    }\n\n    getPageTabRoutes(location: PageLocationId): Route[] {\n        const configs = this.registry.get(location) || [];\n        return configs.map(config => {\n            const route: Route = {\n                path: config.route || '',\n                pathMatch: config.route ? 'prefix' : 'full',\n            };\n\n            let component: Type<any>;\n            if (isComponentWithResolver(config.component)) {\n                const { component: cmp, breadcrumbFn, resolveFn } = config.component;\n                component = cmp;\n                route.resolve = { detail: resolveFn };\n                route.data = {\n                    breadcrumb: data => data.detail.entity.pipe(map(entity => breadcrumbFn(entity))),\n                };\n            } else {\n                component = config.component;\n            }\n            const guards =\n                typeof component.prototype.canDeactivate === 'function' ? [CanDeactivateDetailGuard] : [];\n            route.component = component;\n            route.canDeactivate = guards;\n            if (config.routeConfig) {\n                Object.assign(route, config.routeConfig);\n            }\n\n            return route;\n        });\n    }\n\n    getPageTabs(location: PageLocationId): PageTabConfig[] {\n        return this.registry.get(location)?.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0)) || [];\n    }\n}\n\nfunction isComponentWithResolver(input: any): input is ReturnType<typeof detailComponentWithResolver> {\n    return input && input.hasOwnProperty('resolveFn');\n}\n"]}

package/esm2022/core/providers/permissions/permissions.service.mjs

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * @description
+ * This service is used internally to power components & logic that are dependent on knowing the
+ * current user's permissions in the currently-active channel.
+ */
+export class PermissionsService {
+    constructor() {
+        this.currentUserPermissions = [];
+        this._currentUserPermissions$ = new BehaviorSubject([]);
+        this.currentUserPermissions$ = this._currentUserPermissions$.asObservable();
+    }
+    /**
+     * @description
+     * This is called whenever:
+     * - the user logs in
+     * - the active channel changes
+     *
+     * Since active user validation occurs as part of the main auth guard, we can be assured
+     * that if the user is logged in, then this method will be called with the user's permissions
+     * before any other components are rendered lower down in the component tree.
+     */
+    setCurrentUserPermissions(permissions) {
+        this.currentUserPermissions = permissions;
+        this._currentUserPermissions$.next(permissions);
+    }
+    userHasPermissions(requiredPermissions) {
+        for (const perm of requiredPermissions) {
+            if (this.currentUserPermissions.includes(perm)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PermissionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PermissionsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PermissionsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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