@deenruv/admin-ui 1.0.0

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

@@ -0,0 +1,114 @@
+import { Injectable } from '@angular/core';
+import { notNullOrUndefined } from '@deenruv/common/lib/shared-utils';
+import { BehaviorSubject, combineLatest, first, isObservable, of, Subject, switchMap, } from 'rxjs';
+import { filter, map, startWith, take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../permissions/permissions.service";
+import * as i2 from "../../data/providers/data.service";
+import * as i3 from "../notification/notification.service";
+import * as i4 from "../modal/modal.service";
+export class Alert {
+    constructor(config, context) {
+        this.config = config;
+        this.context = context;
+        this.hasRun$ = new BehaviorSubject(false);
+        this.data$ = new BehaviorSubject(undefined);
+        if (this.config.recheck) {
+            this.config.recheck(this.context).subscribe(() => this.runCheck());
+        }
+        this.activeAlert$ = combineLatest(this.data$, this.hasRun$).pipe(map(([data, hasRun]) => {
+            if (!data) {
+                return;
+            }
+            const isAlert = this.config.isAlert(data, this.context);
+            if (!isAlert) {
+                return;
+            }
+            return {
+                id: this.config.id,
+                runAction: () => {
+                    if (!hasRun) {
+                        this.config.action(data, this.context);
+                        this.hasRun$.next(true);
+                    }
+                },
+                hasRun,
+                label: this.config.label(data, this.context),
+            };
+        }));
+    }
+    get id() {
+        return this.config.id;
+    }
+    runCheck() {
+        const result = this.config.check(this.context);
+        if (result instanceof Promise) {
+            result.then(data => this.data$.next(data));
+        }
+        else if (isObservable(result)) {
+            result.pipe(take(1)).subscribe(data => this.data$.next(data));
+        }
+        else {
+            this.data$.next(result);
+        }
+        this.hasRun$.next(false);
+    }
+}
+export class AlertsService {
+    constructor(permissionsService, injector, dataService, notificationService, modalService) {
+        this.permissionsService = permissionsService;
+        this.injector = injector;
+        this.dataService = dataService;
+        this.notificationService = notificationService;
+        this.modalService = modalService;
+        this.alertsMap = new Map();
+        this.configUpdated = new Subject();
+        const alerts$ = this.configUpdated.pipe(map(() => [...this.alertsMap.values()]), startWith([...this.alertsMap.values()]));
+        this.activeAlerts$ = alerts$.pipe(switchMap(() => {
+            const alerts = [...this.alertsMap.values()];
+            const isAlertStreams = alerts.map(alert => alert.activeAlert$);
+            return combineLatest(isAlertStreams);
+        }), map(alertStates => alertStates.filter(notNullOrUndefined)));
+    }
+    configureAlert(config) {
+        this.hasSufficientPermissions(config.requiredPermissions)
+            .pipe(first())
+            .subscribe(hasPermissions => {
+            if (hasPermissions) {
+                this.alertsMap.set(config.id, new Alert(config, this.createContext()));
+                this.configUpdated.next();
+            }
+        });
+    }
+    hasSufficientPermissions(permissions) {
+        if (!permissions || permissions.length === 0) {
+            return of(true);
+        }
+        return this.permissionsService.currentUserPermissions$.pipe(filter(permissions => permissions.length > 0), map(() => this.permissionsService.userHasPermissions(permissions)));
+    }
+    refresh(id) {
+        if (id) {
+            this.alertsMap.get(id)?.runCheck();
+        }
+        else {
+            this.alertsMap.forEach(config => config.runCheck());
+        }
+    }
+    createContext() {
+        return {
+            injector: this.injector,
+            dataService: this.dataService,
+            notificationService: this.notificationService,
+            modalService: this.modalService,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AlertsService, deps: [{ token: i1.PermissionsService }, { token: i0.Injector }, { token: i2.DataService }, { token: i3.NotificationService }, { token: i4.ModalService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AlertsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AlertsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.PermissionsService }, { type: i0.Injector }, { type: i2.DataService }, { type: i3.NotificationService }, { type: i4.ModalService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alerts.service.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/providers/alerts/alerts.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector } from '@angular/core';\nimport { notNullOrUndefined } from '@deenruv/common/lib/shared-utils';\nimport {\n    BehaviorSubject,\n    combineLatest,\n    first,\n    isObservable,\n    Observable,\n    of,\n    Subject,\n    switchMap,\n} from 'rxjs';\nimport { filter, map, startWith, take } from 'rxjs/operators';\nimport { Permission } from '../../common/generated-types';\nimport { DataService } from '../../data/providers/data.service';\nimport { ModalService } from '../modal/modal.service';\nimport { NotificationService } from '../notification/notification.service';\nimport { PermissionsService } from '../permissions/permissions.service';\n\n/**\n * @description\n * The context object which is passed to the `check`, `isAlert`, `label` and `action` functions of an\n * {@link AlertConfig} object.\n *\n * @since 2.2.0\n * @docsCategory alerts\n */\nexport interface AlertContext {\n    /**\n     * @description\n     * The Angular [Injector](https://angular.dev/api/core/Injector) which can be used to get instances\n     * of services and other providers available in the application.\n     */\n    injector: Injector;\n    /**\n     * @description\n     * The [DataService](/reference/admin-ui-api/services/data-service), which provides methods for querying the\n     * server-side data.\n     */\n    dataService: DataService;\n    /**\n     * @description\n     * The [NotificationService](/reference/admin-ui-api/services/notification-service), which provides methods for\n     * displaying notifications to the user.\n     */\n    notificationService: NotificationService;\n    /**\n     * @description\n     * The [ModalService](/reference/admin-ui-api/services/modal-service), which provides methods for\n     * opening modal dialogs.\n     */\n    modalService: ModalService;\n}\n\n/**\n * @description\n * A configuration object for an Admin UI alert.\n *\n * @since 2.2.0\n * @docsCategory alerts\n */\nexport interface AlertConfig<T = any> {\n    /**\n     * @description\n     * A unique identifier for the alert.\n     */\n    id: string;\n    /**\n     * @description\n     * A function which is gets the data used to determine whether the alert should be shown.\n     * Typically, this function will query the server or some other remote data source.\n     *\n     * This function will be called once when the Admin UI app bootstraps, and can be also\n     * set to run at regular intervals by setting the `recheckIntervalMs` property.\n     */\n    check: (context: AlertContext) => T | Promise<T> | Observable<T>;\n    /**\n     * @description\n     * A function which returns an Observable which is used to determine when to re-run the `check`\n     * function. Whenever the observable emits, the `check` function will be called again.\n     *\n     * A basic time-interval-based recheck can be achieved by using the `interval` function from RxJS.\n     *\n     * @example\n     * ```ts\n     * import { interval } from 'rxjs';\n     *\n     * // ...\n     * recheck: () => interval(60_000)\n     * ```\n     *\n     * If this is not set, the `check` function will only be called once when the Admin UI app bootstraps.\n     *\n     * @default undefined\n     */\n    recheck?: (context: AlertContext) => Observable<any>;\n    /**\n     * @description\n     * A function which determines whether the alert should be shown based on the data returned by the `check`\n     * function.\n     */\n    isAlert: (data: T, context: AlertContext) => boolean;\n    /**\n     * @description\n     * A function which is called when the alert is clicked in the Admin UI.\n     */\n    action: (data: T, context: AlertContext) => void;\n    /**\n     * @description\n     * A function which returns the text used in the UI to describe the alert.\n     */\n    label: (\n        data: T,\n        context: AlertContext,\n    ) => { text: string; translationVars?: { [key: string]: string | number } };\n    /**\n     * @description\n     * A list of permissions which the current Administrator must have in order. If the current\n     * Administrator does not have these permissions, none of the other alert functions will be called.\n     */\n    requiredPermissions?: Permission[];\n}\n\nexport interface ActiveAlert {\n    id: string;\n    runAction: () => void;\n    hasRun: boolean;\n    label: { text: string; translationVars?: { [key: string]: string | number } };\n}\n\nexport class Alert<T> {\n    activeAlert$: Observable<ActiveAlert | undefined>;\n    private hasRun$ = new BehaviorSubject(false);\n    private data$ = new BehaviorSubject<T | undefined>(undefined);\n    constructor(\n        private config: AlertConfig<T>,\n        private context: AlertContext,\n    ) {\n        if (this.config.recheck) {\n            this.config.recheck(this.context).subscribe(() => this.runCheck());\n        }\n        this.activeAlert$ = combineLatest(this.data$, this.hasRun$).pipe(\n            map(([data, hasRun]) => {\n                if (!data) {\n                    return;\n                }\n                const isAlert = this.config.isAlert(data, this.context);\n                if (!isAlert) {\n                    return;\n                }\n                return {\n                    id: this.config.id,\n                    runAction: () => {\n                        if (!hasRun) {\n                            this.config.action(data, this.context);\n                            this.hasRun$.next(true);\n                        }\n                    },\n                    hasRun,\n                    label: this.config.label(data, this.context),\n                };\n            }),\n        );\n    }\n    get id() {\n        return this.config.id;\n    }\n    runCheck() {\n        const result = this.config.check(this.context);\n        if (result instanceof Promise) {\n            result.then(data => this.data$.next(data));\n        } else if (isObservable(result)) {\n            result.pipe(take(1)).subscribe(data => this.data$.next(data));\n        } else {\n            this.data$.next(result);\n        }\n        this.hasRun$.next(false);\n    }\n}\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class AlertsService {\n    activeAlerts$: Observable<ActiveAlert[]>;\n    private alertsMap = new Map<string, Alert<any>>();\n    private configUpdated = new Subject<void>();\n\n    constructor(\n        private permissionsService: PermissionsService,\n        private injector: Injector,\n        private dataService: DataService,\n        private notificationService: NotificationService,\n        private modalService: ModalService,\n    ) {\n        const alerts$ = this.configUpdated.pipe(\n            map(() => [...this.alertsMap.values()]),\n            startWith([...this.alertsMap.values()]),\n        );\n\n        this.activeAlerts$ = alerts$.pipe(\n            switchMap(() => {\n                const alerts = [...this.alertsMap.values()];\n                const isAlertStreams = alerts.map(alert => alert.activeAlert$);\n                return combineLatest(isAlertStreams);\n            }),\n            map(alertStates => alertStates.filter(notNullOrUndefined)),\n        );\n    }\n\n    configureAlert<T>(config: AlertConfig<T>) {\n        this.hasSufficientPermissions(config.requiredPermissions)\n            .pipe(first())\n            .subscribe(hasPermissions => {\n                if (hasPermissions) {\n                    this.alertsMap.set(config.id, new Alert(config, this.createContext()));\n                    this.configUpdated.next();\n                }\n            });\n    }\n\n    hasSufficientPermissions(permissions?: Permission[]) {\n        if (!permissions || permissions.length === 0) {\n            return of(true);\n        }\n        return this.permissionsService.currentUserPermissions$.pipe(\n            filter(permissions => permissions.length > 0),\n            map(() => this.permissionsService.userHasPermissions(permissions)),\n        );\n    }\n\n    refresh(id?: string) {\n        if (id) {\n            this.alertsMap.get(id)?.runCheck();\n        } else {\n            this.alertsMap.forEach(config => config.runCheck());\n        }\n    }\n\n    protected createContext(): AlertContext {\n        return {\n            injector: this.injector,\n            dataService: this.dataService,\n            notificationService: this.notificationService,\n            modalService: this.modalService,\n        };\n    }\n}\n"]}

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

@@ -0,0 +1,124 @@
+import { Injectable } from '@angular/core';
+import { DEFAULT_CHANNEL_CODE } from '@deenruv/common/lib/shared-constants';
+import { of } from 'rxjs';
+import { catchError, map, mapTo, mergeMap, switchMap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../local-storage/local-storage.service";
+import * as i2 from "../../data/providers/data.service";
+import * as i3 from "../../data/server-config";
+import * as i4 from "../permissions/permissions.service";
+/**
+ * This service handles logic relating to authentication of the current user.
+ */
+export class AuthService {
+    constructor(localStorageService, dataService, serverConfigService, permissionsService) {
+        this.localStorageService = localStorageService;
+        this.dataService = dataService;
+        this.serverConfigService = serverConfigService;
+        this.permissionsService = permissionsService;
+    }
+    /**
+     * Attempts to log in via the REST login endpoint and updates the app
+     * state on success.
+     */
+    logIn(username, password, rememberMe) {
+        return this.dataService.auth.attemptLogin(username, password, rememberMe).pipe(switchMap(response => {
+            if (response.login.__typename === 'CurrentUser') {
+                this.setChannelToken(response.login.channels);
+            }
+            return this.serverConfigService.getServerConfig().then(() => response.login);
+        }), switchMap(login => {
+            if (login.__typename === 'CurrentUser') {
+                const activeChannel = this.getActiveChannel(login.channels);
+                this.permissionsService.setCurrentUserPermissions(activeChannel.permissions);
+                return this.dataService.administrator.getActiveAdministrator().single$.pipe(switchMap(({ activeAdministrator }) => {
+                    if (activeAdministrator) {
+                        return this.dataService.client
+                            .loginSuccess(activeAdministrator.id, `${activeAdministrator.firstName} ${activeAdministrator.lastName}`, activeChannel.id, login.channels)
+                            .pipe(map(() => login));
+                    }
+                    else {
+                        return of(login);
+                    }
+                }));
+            }
+            return of(login);
+        }));
+    }
+    /**
+     * Update the user status to being logged out.
+     */
+    logOut() {
+        return this.dataService.client.userStatus().single$.pipe(switchMap(status => {
+            if (status.userStatus.isLoggedIn) {
+                return this.dataService.client
+                    .logOut()
+                    .pipe(mergeMap(() => this.dataService.auth.logOut()));
+            }
+            else {
+                return [];
+            }
+        }), mapTo(true));
+    }
+    /**
+     * Checks the app state to see if the user is already logged in,
+     * and if not, attempts to validate any auth token found.
+     */
+    checkAuthenticatedStatus() {
+        return this.dataService.client.userStatus().single$.pipe(mergeMap(data => {
+            if (!data.userStatus.isLoggedIn) {
+                return this.validateAuthToken();
+            }
+            else {
+                return of(true);
+            }
+        }));
+    }
+    /**
+     * Checks for an auth token and if found, attempts to validate
+     * that token against the API.
+     */
+    validateAuthToken() {
+        return this.dataService.auth.currentUser().single$.pipe(mergeMap(({ me }) => {
+            if (!me) {
+                return of(false);
+            }
+            this.setChannelToken(me.channels);
+            const activeChannel = this.getActiveChannel(me.channels);
+            this.permissionsService.setCurrentUserPermissions(activeChannel.permissions);
+            return this.dataService.administrator.getActiveAdministrator().single$.pipe(switchMap(({ activeAdministrator }) => {
+                if (activeAdministrator) {
+                    return this.dataService.client
+                        .loginSuccess(activeAdministrator.id, `${activeAdministrator.firstName} ${activeAdministrator.lastName}`, activeChannel.id, me.channels)
+                        .pipe(map(() => true));
+                }
+                else {
+                    return of(false);
+                }
+            }));
+        }), mapTo(true), catchError(err => of(false)));
+    }
+    getActiveChannel(userChannels) {
+        const lastActiveChannelToken = this.localStorageService.get('activeChannelToken');
+        if (lastActiveChannelToken) {
+            const lastActiveChannel = userChannels.find(c => c.token === lastActiveChannelToken);
+            if (lastActiveChannel) {
+                return lastActiveChannel;
+            }
+        }
+        const defaultChannel = userChannels.find(c => c.code === DEFAULT_CHANNEL_CODE);
+        return defaultChannel || userChannels[0];
+    }
+    setChannelToken(userChannels) {
+        this.localStorageService.set('activeChannelToken', this.getActiveChannel(userChannels).token);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, deps: [{ token: i1.LocalStorageService }, { token: i2.DataService }, { token: i3.ServerConfigService }, { token: i4.PermissionsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.LocalStorageService }, { type: i2.DataService }, { type: i3.ServerConfigService }, { type: i4.PermissionsService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/providers/auth/auth.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAC5E,OAAO,EAAc,EAAE,EAAE,MAAM,MAAM,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;;;;;;AAQ7E;;GAEG;AAIH,MAAM,OAAO,WAAW;IACpB,YACY,mBAAwC,EACxC,WAAwB,EACxB,mBAAwC,EACxC,kBAAsC;QAHtC,wBAAmB,GAAnB,mBAAmB,CAAqB;QACxC,gBAAW,GAAX,WAAW,CAAa;QACxB,wBAAmB,GAAnB,mBAAmB,CAAqB;QACxC,uBAAkB,GAAlB,kBAAkB,CAAoB;IAC/C,CAAC;IAEJ;;;OAGG;IACH,KAAK,CACD,QAAgB,EAChB,QAAgB,EAChB,UAAmB;QAEnB,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC,IAAI,CAC1E,SAAS,CAAC,QAAQ,CAAC,EAAE;YACjB,IAAI,QAAQ,CAAC,KAAK,CAAC,UAAU,KAAK,aAAa,EAAE,CAAC;gBAC9C,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;YAClD,CAAC;YACD,OAAO,IAAI,CAAC,mBAAmB,CAAC,eAAe,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACjF,CAAC,CAAC,EACF,SAAS,CAAC,KAAK,CAAC,EAAE;YACd,IAAI,KAAK,CAAC,UAAU,KAAK,aAAa,EAAE,CAAC;gBACrC,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;gBAC5D,IAAI,CAAC,kBAAkB,CAAC,yBAAyB,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;gBAC7E,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,sBAAsB,EAAE,CAAC,OAAO,CAAC,IAAI,CACvE,SAAS,CAAC,CAAC,EAAE,mBAAmB,EAAE,EAAE,EAAE;oBAClC,IAAI,mBAAmB,EAAE,CAAC;wBACtB,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM;6BACzB,YAAY,CACT,mBAAmB,CAAC,EAAE,EACtB,GAAG,mBAAmB,CAAC,SAAS,IAAI,mBAAmB,CAAC,QAAQ,EAAE,EAClE,aAAa,CAAC,EAAE,EAChB,KAAK,CAAC,QAAQ,CACjB;6BACA,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;oBAChC,CAAC;yBAAM,CAAC;wBACJ,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;oBACrB,CAAC;gBACL,CAAC,CAAC,CACL,CAAC;YACN,CAAC;YACD,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC,CAAC,CACL,CAAC;IACN,CAAC;IAED;;OAEG;IACH,MAAM;QACF,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,IAAI,CACpD,SAAS,CAAC,MAAM,CAAC,EAAE;YACf,IAAI,MAAM,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC;gBAC/B,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM;qBACzB,MAAM,EAAE;qBACR,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;YAC9D,CAAC;iBAAM,CAAC;gBACJ,OAAO,EAAE,CAAC;YACd,CAAC;QACL,CAAC,CAAC,EACF,KAAK,CAAC,IAAI,CAAC,CACd,CAAC;IACN,CAAC;IAED;;;OAGG;IACH,wBAAwB;QACpB,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,IAAI,CACpD,QAAQ,CAAC,IAAI,CAAC,EAAE;YACZ,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC;gBAC9B,OAAO,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACpC,CAAC;iBAAM,CAAC;gBACJ,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;YACpB,CAAC;QACL,CAAC,CAAC,CACL,CAAC;IACN,CAAC;IAED;;;OAGG;IACH,iBAAiB;QACb,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,IAAI,CACnD,QAAQ,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE;YAChB,IAAI,CAAC,EAAE,EAAE,CAAC;gBACN,OAAO,EAAE,CAAC,KAAK,CAAQ,CAAC;YAC5B,CAAC;YACD,IAAI,CAAC,eAAe,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC;YAClC,MAAM,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC;YACzD,IAAI,CAAC,kBAAkB,CAAC,yBAAyB,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;YAC7E,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,sBAAsB,EAAE,CAAC,OAAO,CAAC,IAAI,CACvE,SAAS,CAAC,CAAC,EAAE,mBAAmB,EAAE,EAAE,EAAE;gBAClC,IAAI,mBAAmB,EAAE,CAAC;oBACtB,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM;yBACzB,YAAY,CACT,mBAAmB,CAAC,EAAE,EACtB,GAAG,mBAAmB,CAAC,SAAS,IAAI,mBAAmB,CAAC,QAAQ,EAAE,EAClE,aAAa,CAAC,EAAE,EAChB,EAAE,CAAC,QAAQ,CACd;yBACA,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;gBAC/B,CAAC;qBAAM,CAAC;oBACJ,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;gBACrB,CAAC;YACL,CAAC,CAAC,CACL,CAAC;QACN,CAAC,CAAC,EACF,KAAK,CAAC,IAAI,CAAC,EACX,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAC/B,CAAC;IACN,CAAC;IAEO,gBAAgB,CAAC,YAA6C;QAClE,MAAM,sBAAsB,GAAG,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;QAClF,IAAI,sBAAsB,EAAE,CAAC;YACzB,MAAM,iBAAiB,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,sBAAsB,CAAC,CAAC;YACrF,IAAI,iBAAiB,EAAE,CAAC;gBACpB,OAAO,iBAAiB,CAAC;YAC7B,CAAC;QACL,CAAC;QACD,MAAM,cAAc,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,oBAAoB,CAAC,CAAC;QAC/E,OAAO,cAAc,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC;IAC7C,CAAC;IAEO,eAAe,CAAC,YAA6C;QACjE,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,oBAAoB,EAAE,IAAI,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC,KAAK,CAAC,CAAC;IAClG,CAAC;+GArIQ,WAAW;mHAAX,WAAW,cAFR,MAAM;;4FAET,WAAW;kBAHvB,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { DEFAULT_CHANNEL_CODE } from '@deenruv/common/lib/shared-constants';\nimport { Observable, of } from 'rxjs';\nimport { catchError, map, mapTo, mergeMap, switchMap } from 'rxjs/operators';\n\nimport { AttemptLoginMutation, CurrentUserFragment } from '../../common/generated-types';\nimport { DataService } from '../../data/providers/data.service';\nimport { ServerConfigService } from '../../data/server-config';\nimport { LocalStorageService } from '../local-storage/local-storage.service';\nimport { PermissionsService } from '../permissions/permissions.service';\n\n/**\n * This service handles logic relating to authentication of the current user.\n */\n@Injectable({\n    providedIn: 'root',\n})\nexport class AuthService {\n    constructor(\n        private localStorageService: LocalStorageService,\n        private dataService: DataService,\n        private serverConfigService: ServerConfigService,\n        private permissionsService: PermissionsService,\n    ) {}\n\n    /**\n     * Attempts to log in via the REST login endpoint and updates the app\n     * state on success.\n     */\n    logIn(\n        username: string,\n        password: string,\n        rememberMe: boolean,\n    ): Observable<AttemptLoginMutation['login']> {\n        return this.dataService.auth.attemptLogin(username, password, rememberMe).pipe(\n            switchMap(response => {\n                if (response.login.__typename === 'CurrentUser') {\n                    this.setChannelToken(response.login.channels);\n                }\n                return this.serverConfigService.getServerConfig().then(() => response.login);\n            }),\n            switchMap(login => {\n                if (login.__typename === 'CurrentUser') {\n                    const activeChannel = this.getActiveChannel(login.channels);\n                    this.permissionsService.setCurrentUserPermissions(activeChannel.permissions);\n                    return this.dataService.administrator.getActiveAdministrator().single$.pipe(\n                        switchMap(({ activeAdministrator }) => {\n                            if (activeAdministrator) {\n                                return this.dataService.client\n                                    .loginSuccess(\n                                        activeAdministrator.id,\n                                        `${activeAdministrator.firstName} ${activeAdministrator.lastName}`,\n                                        activeChannel.id,\n                                        login.channels,\n                                    )\n                                    .pipe(map(() => login));\n                            } else {\n                                return of(login);\n                            }\n                        }),\n                    );\n                }\n                return of(login);\n            }),\n        );\n    }\n\n    /**\n     * Update the user status to being logged out.\n     */\n    logOut(): Observable<boolean> {\n        return this.dataService.client.userStatus().single$.pipe(\n            switchMap(status => {\n                if (status.userStatus.isLoggedIn) {\n                    return this.dataService.client\n                        .logOut()\n                        .pipe(mergeMap(() => this.dataService.auth.logOut()));\n                } else {\n                    return [];\n                }\n            }),\n            mapTo(true),\n        );\n    }\n\n    /**\n     * Checks the app state to see if the user is already logged in,\n     * and if not, attempts to validate any auth token found.\n     */\n    checkAuthenticatedStatus(): Observable<boolean> {\n        return this.dataService.client.userStatus().single$.pipe(\n            mergeMap(data => {\n                if (!data.userStatus.isLoggedIn) {\n                    return this.validateAuthToken();\n                } else {\n                    return of(true);\n                }\n            }),\n        );\n    }\n\n    /**\n     * Checks for an auth token and if found, attempts to validate\n     * that token against the API.\n     */\n    validateAuthToken(): Observable<boolean> {\n        return this.dataService.auth.currentUser().single$.pipe(\n            mergeMap(({ me }) => {\n                if (!me) {\n                    return of(false) as any;\n                }\n                this.setChannelToken(me.channels);\n                const activeChannel = this.getActiveChannel(me.channels);\n                this.permissionsService.setCurrentUserPermissions(activeChannel.permissions);\n                return this.dataService.administrator.getActiveAdministrator().single$.pipe(\n                    switchMap(({ activeAdministrator }) => {\n                        if (activeAdministrator) {\n                            return this.dataService.client\n                                .loginSuccess(\n                                    activeAdministrator.id,\n                                    `${activeAdministrator.firstName} ${activeAdministrator.lastName}`,\n                                    activeChannel.id,\n                                    me.channels,\n                                )\n                                .pipe(map(() => true));\n                        } else {\n                            return of(false);\n                        }\n                    }),\n                );\n            }),\n            mapTo(true),\n            catchError(err => of(false)),\n        );\n    }\n\n    private getActiveChannel(userChannels: CurrentUserFragment['channels']) {\n        const lastActiveChannelToken = this.localStorageService.get('activeChannelToken');\n        if (lastActiveChannelToken) {\n            const lastActiveChannel = userChannels.find(c => c.token === lastActiveChannelToken);\n            if (lastActiveChannel) {\n                return lastActiveChannel;\n            }\n        }\n        const defaultChannel = userChannels.find(c => c.code === DEFAULT_CHANNEL_CODE);\n        return defaultChannel || userChannels[0];\n    }\n\n    private setChannelToken(userChannels: CurrentUserFragment['channels']) {\n        this.localStorageService.set('activeChannelToken', this.getActiveChannel(userChannels).token);\n    }\n}\n"]}

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

@@ -0,0 +1,109 @@
+import { Injectable } from '@angular/core';
+import { NavigationEnd, PRIMARY_OUTLET } from '@angular/router';
+import { flatten } from 'lodash';
+import { combineLatest as observableCombineLatest, isObservable, of as observableOf, Subject, } from 'rxjs';
+import { filter, map, shareReplay, startWith, switchMap, takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../../data/providers/data.service";
+export class BreadcrumbService {
+    constructor(router, route, dataService) {
+        this.router = router;
+        this.route = route;
+        this.dataService = dataService;
+        this.destroy$ = new Subject();
+        this.breadcrumbs$ = this.router.events.pipe(filter(event => event instanceof NavigationEnd), takeUntil(this.destroy$), startWith(true), switchMap(() => this.generateBreadcrumbs(this.route.root)), shareReplay(1));
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    generateBreadcrumbs(rootRoute) {
+        const breadcrumbParts = this.assembleBreadcrumbParts(rootRoute);
+        const breadcrumbObservables$ = breadcrumbParts.map(({ value$, path }) => value$.pipe(map(value => {
+            if (isBreadcrumbLabelLinkPair(value)) {
+                return {
+                    label: value.label,
+                    link: this.normalizeRelativeLinks(value.link, path),
+                };
+            }
+            else if (isBreadcrumbPairArray(value)) {
+                return value.map(val => ({
+                    label: val.label,
+                    link: this.normalizeRelativeLinks(val.link, path),
+                }));
+            }
+            else {
+                return {
+                    label: value,
+                    link: '/' + path.join('/'),
+                };
+            }
+        })));
+        return observableCombineLatest(breadcrumbObservables$).pipe(map(links => flatten(links)));
+    }
+    /**
+     * Walks the route definition tree to assemble an array from which the breadcrumbs can be derived.
+     */
+    assembleBreadcrumbParts(rootRoute) {
+        const breadcrumbParts = [];
+        const segmentPaths = [];
+        let currentRoute = rootRoute;
+        do {
+            const childRoutes = currentRoute.children;
+            currentRoute = null;
+            childRoutes.forEach((route) => {
+                if (route.outlet === PRIMARY_OUTLET) {
+                    const routeSnapshot = route.snapshot;
+                    let breadcrumbDef = route.routeConfig && route.routeConfig.data && route.routeConfig.data['breadcrumb'];
+                    segmentPaths.push(routeSnapshot.url.map(segment => segment.path).join('/'));
+                    if (breadcrumbDef) {
+                        if (isBreadcrumbFunction(breadcrumbDef)) {
+                            breadcrumbDef = breadcrumbDef(routeSnapshot.data, routeSnapshot.params, this.dataService);
+                        }
+                        const observableValue = isObservable(breadcrumbDef)
+                            ? breadcrumbDef
+                            : observableOf(breadcrumbDef);
+                        breadcrumbParts.push({ value$: observableValue, path: segmentPaths.slice() });
+                    }
+                    currentRoute = route;
+                }
+            });
+        } while (currentRoute);
+        return breadcrumbParts;
+    }
+    /**
+     * Accounts for relative routes in the link array, i.e. arrays whose first element is either:
+     * * `./`   - this appends the rest of the link segments to the current active route
+     * * `../`  - this removes the last segment of the current active route, and appends the link segments
+     *            to the parent route.
+     */
+    normalizeRelativeLinks(link, segmentPaths) {
+        const clone = link.slice();
+        if (clone[0] === './') {
+            clone[0] = segmentPaths.join('/');
+        }
+        if (clone[0] === '../') {
+            clone[0] = segmentPaths.slice(0, -1).join('/');
+        }
+        return clone.filter(segment => segment !== '');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BreadcrumbService, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }, { token: i2.DataService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BreadcrumbService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BreadcrumbService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i1.ActivatedRoute }, { type: i2.DataService }] });
+function isBreadcrumbFunction(value) {
+    return typeof value === 'function';
+}
+function isBreadcrumbLabelLinkPair(value) {
+    return value.hasOwnProperty('label') && value.hasOwnProperty('link');
+}
+function isBreadcrumbPairArray(value) {
+    return Array.isArray(value) && isBreadcrumbLabelLinkPair(value[0]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"breadcrumb.service.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/providers/breadcrumb/breadcrumb.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\nimport { ActivatedRoute, Data, NavigationEnd, Params, PRIMARY_OUTLET, Router } from '@angular/router';\nimport { flatten } from 'lodash';\nimport {\n    combineLatest as observableCombineLatest,\n    isObservable,\n    Observable,\n    of as observableOf,\n    Subject,\n} from 'rxjs';\nimport { filter, map, shareReplay, startWith, switchMap, takeUntil } from 'rxjs/operators';\nimport { DataService } from '../../data/providers/data.service';\n\nexport type BreadcrumbString = string;\n\nexport interface BreadcrumbLabelLinkPair {\n    label: string;\n    link: any[];\n}\n\nexport type BreadcrumbValue = BreadcrumbString | BreadcrumbLabelLinkPair | BreadcrumbLabelLinkPair[];\nexport type BreadcrumbFunction = (\n    data: Data,\n    params: Params,\n    dataService: DataService,\n) => BreadcrumbValue | Observable<BreadcrumbValue>;\nexport type BreadcrumbDefinition = BreadcrumbValue | BreadcrumbFunction | Observable<BreadcrumbValue>;\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class BreadcrumbService implements OnDestroy {\n    breadcrumbs$: Observable<Array<{ link: string | any[]; label: string }>>;\n    private destroy$ = new Subject<void>();\n\n    constructor(private router: Router, private route: ActivatedRoute, private dataService: DataService) {\n        this.breadcrumbs$ = this.router.events.pipe(\n            filter(event => event instanceof NavigationEnd),\n            takeUntil(this.destroy$),\n            startWith(true),\n            switchMap(() => this.generateBreadcrumbs(this.route.root)),\n            shareReplay(1),\n        );\n    }\n\n    ngOnDestroy(): void {\n        this.destroy$.next();\n        this.destroy$.complete();\n    }\n\n    private generateBreadcrumbs(\n        rootRoute: ActivatedRoute,\n    ): Observable<Array<{ link: Array<string | any>; label: string }>> {\n        const breadcrumbParts = this.assembleBreadcrumbParts(rootRoute);\n        const breadcrumbObservables$ = breadcrumbParts.map(\n            ({ value$, path }) =>\n                value$.pipe(\n                    map(value => {\n                        if (isBreadcrumbLabelLinkPair(value)) {\n                            return {\n                                label: value.label,\n                                link: this.normalizeRelativeLinks(value.link, path),\n                            };\n                        } else if (isBreadcrumbPairArray(value)) {\n                            return value.map(val => ({\n                                label: val.label,\n                                link: this.normalizeRelativeLinks(val.link, path),\n                            }));\n                        } else {\n                            return {\n                                label: value,\n                                link: '/' + path.join('/'),\n                            };\n                        }\n                    }),\n                ) as Observable<BreadcrumbLabelLinkPair | BreadcrumbLabelLinkPair[]>,\n        );\n\n        return observableCombineLatest(breadcrumbObservables$).pipe(map(links => flatten(links)));\n    }\n\n    /**\n     * Walks the route definition tree to assemble an array from which the breadcrumbs can be derived.\n     */\n    private assembleBreadcrumbParts(\n        rootRoute: ActivatedRoute,\n    ): Array<{ value$: Observable<BreadcrumbValue>; path: string[] }> {\n        const breadcrumbParts: Array<{ value$: Observable<BreadcrumbValue>; path: string[] }> = [];\n        const segmentPaths: string[] = [];\n        let currentRoute: ActivatedRoute | null = rootRoute;\n        do {\n            const childRoutes = currentRoute.children;\n            currentRoute = null;\n            childRoutes.forEach((route: ActivatedRoute) => {\n                if (route.outlet === PRIMARY_OUTLET) {\n                    const routeSnapshot = route.snapshot;\n                    let breadcrumbDef: BreadcrumbDefinition | undefined =\n                        route.routeConfig && route.routeConfig.data && route.routeConfig.data['breadcrumb'];\n                    segmentPaths.push(routeSnapshot.url.map(segment => segment.path).join('/'));\n\n                    if (breadcrumbDef) {\n                        if (isBreadcrumbFunction(breadcrumbDef)) {\n                            breadcrumbDef = breadcrumbDef(\n                                routeSnapshot.data,\n                                routeSnapshot.params,\n                                this.dataService,\n                            );\n                        }\n                        const observableValue = isObservable(breadcrumbDef)\n                            ? breadcrumbDef\n                            : observableOf(breadcrumbDef);\n                        breadcrumbParts.push({ value$: observableValue, path: segmentPaths.slice() });\n                    }\n                    currentRoute = route;\n                }\n            });\n        } while (currentRoute);\n\n        return breadcrumbParts;\n    }\n\n    /**\n     * Accounts for relative routes in the link array, i.e. arrays whose first element is either:\n     * * `./`   - this appends the rest of the link segments to the current active route\n     * * `../`  - this removes the last segment of the current active route, and appends the link segments\n     *            to the parent route.\n     */\n    private normalizeRelativeLinks(link: any[], segmentPaths: string[]): any[] {\n        const clone = link.slice();\n        if (clone[0] === './') {\n            clone[0] = segmentPaths.join('/');\n        }\n        if (clone[0] === '../') {\n            clone[0] = segmentPaths.slice(0, -1).join('/');\n        }\n        return clone.filter(segment => segment !== '');\n    }\n}\n\nfunction isBreadcrumbFunction(value: BreadcrumbDefinition): value is BreadcrumbFunction {\n    return typeof value === 'function';\n}\n\nfunction isBreadcrumbLabelLinkPair(value: BreadcrumbValue): value is BreadcrumbLabelLinkPair {\n    return value.hasOwnProperty('label') && value.hasOwnProperty('link');\n}\n\nfunction isBreadcrumbPairArray(value: BreadcrumbValue): value is BreadcrumbLabelLinkPair[] {\n    return Array.isArray(value) && isBreadcrumbLabelLinkPair(value[0]);\n}\n"]}

package/esm2022/core/providers/bulk-action-registry/bulk-action-registry.service.mjs

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class BulkActionRegistryService {
+    constructor() {
+        this.locationBulActionMap = new Map();
+    }
+    registerBulkAction(bulkAction) {
+        if (!this.locationBulActionMap.has(bulkAction.location)) {
+            this.locationBulActionMap.set(bulkAction.location, new Set([bulkAction]));
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            this.locationBulActionMap.get(bulkAction.location).add(bulkAction);
+        }
+    }
+    getBulkActionsForLocation(id) {
+        return [...(this.locationBulActionMap.get(id)?.values() ?? [])];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BulkActionRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BulkActionRegistryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BulkActionRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/providers/bulk-action-registry/bulk-action-types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import { DEFAULT_CHANNEL_CODE } from '@deenruv/common/lib/shared-constants';
+import { map, shareReplay, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../data/providers/data.service";
+import * as i2 from "../local-storage/local-storage.service";
+import * as i3 from "../permissions/permissions.service";
+export class ChannelService {
+    constructor(dataService, localStorageService, permissionsService) {
+        this.dataService = dataService;
+        this.localStorageService = localStorageService;
+        this.permissionsService = permissionsService;
+        this.defaultChannelIsActive$ = this.dataService.client
+            .userStatus()
+            .mapStream(({ userStatus }) => {
+            const activeChannel = userStatus.channels.find(c => c.id === userStatus.activeChannelId);
+            return activeChannel ? activeChannel.code === DEFAULT_CHANNEL_CODE : false;
+        })
+            .pipe(shareReplay(1));
+    }
+    setActiveChannel(channelId) {
+        return this.dataService.client.setActiveChannel(channelId).pipe(map(({ setActiveChannel }) => setActiveChannel), tap(userStatus => {
+            const activeChannel = userStatus.channels.find(c => c.id === channelId);
+            if (activeChannel) {
+                this.localStorageService.set('activeChannelToken', activeChannel.token);
+                this.permissionsService.setCurrentUserPermissions(activeChannel.permissions);
+            }
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ChannelService, deps: [{ token: i1.DataService }, { token: i2.LocalStorageService }, { token: i3.PermissionsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ChannelService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ChannelService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.DataService }, { type: i2.LocalStorageService }, { type: i3.PermissionsService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/providers/component-registry/component-registry.service.mjs

@@ -0,0 +1,25 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ComponentRegistryService {
+    constructor() {
+        this.inputComponentMap = new Map();
+    }
+    registerInputComponent(id, component, providers) {
+        if (this.inputComponentMap.has(id)) {
+            throw new Error(`Cannot register an InputComponent with the id "${id}", as one with that id already exists`);
+        }
+        this.inputComponentMap.set(id, { type: component, providers: providers || [] });
+    }
+    getInputComponent(id) {
+        return this.inputComponentMap.get(id);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ComponentRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ComponentRegistryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ComponentRegistryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,21 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../data/server-config";
+export class CurrencyService {
+    constructor(serverConfigService) {
+        this.precision = serverConfigService.serverConfig.moneyStrategyPrecision;
+        this.precisionFactor = Math.pow(10, this.precision);
+    }
+    toMajorUnits(value) {
+        return value / this.precisionFactor;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CurrencyService, deps: [{ token: i1.ServerConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CurrencyService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CurrencyService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.ServerConfigService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VycmVuY3kuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvY29yZS9zcmMvcHJvdmlkZXJzL2N1cnJlbmN5L2N1cnJlbmN5LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7O0FBTTNDLE1BQU0sT0FBTyxlQUFlO0lBR3hCLFlBQVksbUJBQXdDO1FBQ2hELElBQUksQ0FBQyxTQUFTLEdBQUcsbUJBQW1CLENBQUMsWUFBWSxDQUFDLHNCQUFzQixDQUFDO1FBQ3pFLElBQUksQ0FBQyxlQUFlLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLEVBQUUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ3hELENBQUM7SUFFRCxZQUFZLENBQUMsS0FBYTtRQUN0QixPQUFPLEtBQUssR0FBRyxJQUFJLENBQUMsZUFBZSxDQUFDO0lBQ3hDLENBQUM7K0dBVlEsZUFBZTttSEFBZixlQUFlLGNBRlosTUFBTTs7NEZBRVQsZUFBZTtrQkFIM0IsVUFBVTttQkFBQztvQkFDUixVQUFVLEVBQUUsTUFBTTtpQkFDckIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBTZXJ2ZXJDb25maWdTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vZGF0YS9zZXJ2ZXItY29uZmlnJztcblxuQEluamVjdGFibGUoe1xuICAgIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgQ3VycmVuY3lTZXJ2aWNlIHtcbiAgICByZWFkb25seSBwcmVjaXNpb246IG51bWJlcjtcbiAgICByZWFkb25seSBwcmVjaXNpb25GYWN0b3I6IG51bWJlcjtcbiAgICBjb25zdHJ1Y3RvcihzZXJ2ZXJDb25maWdTZXJ2aWNlOiBTZXJ2ZXJDb25maWdTZXJ2aWNlKSB7XG4gICAgICAgIHRoaXMucHJlY2lzaW9uID0gc2VydmVyQ29uZmlnU2VydmljZS5zZXJ2ZXJDb25maWcubW9uZXlTdHJhdGVneVByZWNpc2lvbjtcbiAgICAgICAgdGhpcy5wcmVjaXNpb25GYWN0b3IgPSBNYXRoLnBvdygxMCwgdGhpcy5wcmVjaXNpb24pO1xuICAgIH1cblxuICAgIHRvTWFqb3JVbml0cyh2YWx1ZTogbnVtYmVyKTogbnVtYmVyIHtcbiAgICAgICAgcmV0dXJuIHZhbHVlIC8gdGhpcy5wcmVjaXNpb25GYWN0b3I7XG4gICAgfVxufVxuIl19

package/esm2022/core/providers/custom-detail-component/custom-detail-component-types.mjs

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