@kolektor/nucleus-notifications 0.0.12-pre.7931 → 0.1.0-pre.124

package/README.md

@@ -0,0 +1,7 @@
+# nucleus-notifications
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test nucleus-notifications` to execute the unit tests.

package/esm2022/index.mjs

@@ -0,0 +1,4 @@
+export * from './lib/nucleus-notifications.service';
+export * from './lib/nucleus-notifications.module';
+export * from './lib/models';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL25nL251Y2xldXMtbm90aWZpY2F0aW9ucy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9saWIvbnVjbGV1cy1ub3RpZmljYXRpb25zLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbnVjbGV1cy1ub3RpZmljYXRpb25zLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9tb2RlbHMnO1xuIl19

package/esm2022/kolektor-nucleus-notifications.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia29sZWt0b3ItbnVjbGV1cy1ub3RpZmljYXRpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9uZy9udWNsZXVzLW5vdGlmaWNhdGlvbnMvc3JjL2tvbGVrdG9yLW51Y2xldXMtbm90aWZpY2F0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/lib/models.mjs

@@ -0,0 +1,23 @@
+export class Notification {
+}
+export class Identity {
+}
+export class Recipient {
+}
+export class NotificationData {
+}
+export class WebKey {
+}
+export class Registration {
+}
+export class RegistrationResult {
+}
+export class PayloadData {
+}
+export class NucleusNotificationsConfig {
+}
+export class NotificationClick {
+}
+export class UserChannelConfig {
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/nucleus-notifications.module.mjs

@@ -0,0 +1,25 @@
+import { NgModule } from '@angular/core';
+import { NucleusNotificationsConfig } from './models';
+import * as i0 from "@angular/core";
+export class NucleusNotificationsModule {
+    static forRoot(config) {
+        return {
+            ngModule: NucleusNotificationsModule,
+            providers: [
+                { provide: NucleusNotificationsConfig, useValue: config }
+            ]
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusNotificationsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: NucleusNotificationsModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusNotificationsModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusNotificationsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [],
+                    exports: []
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVjbGV1cy1ub3RpZmljYXRpb25zLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbmcvbnVjbGV1cy1ub3RpZmljYXRpb25zL3NyYy9saWIvbnVjbGV1cy1ub3RpZmljYXRpb25zLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUF1QixNQUFNLGVBQWUsQ0FBQztBQUM5RCxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxVQUFVLENBQUM7O0FBUXRELE1BQU0sT0FBTywwQkFBMEI7SUFFckMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxNQUFrQztRQUMvQyxPQUFPO1lBQ0wsUUFBUSxFQUFFLDBCQUEwQjtZQUNwQyxTQUFTLEVBQUU7Z0JBQ1QsRUFBRSxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsUUFBUSxFQUFFLE1BQU0sRUFBRTthQUMxRDtTQUNGLENBQUM7SUFDSixDQUFDOytHQVRVLDBCQUEwQjtnSEFBMUIsMEJBQTBCO2dIQUExQiwwQkFBMEI7OzRGQUExQiwwQkFBMEI7a0JBTnRDLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFLEVBQUU7b0JBQ2hCLE9BQU8sRUFBRSxFQUNSO29CQUNELE9BQU8sRUFBRSxFQUFFO2lCQUNaIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUsIE1vZHVsZVdpdGhQcm92aWRlcnMgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE51Y2xldXNOb3RpZmljYXRpb25zQ29uZmlnIH0gZnJvbSAnLi9tb2RlbHMnO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtdLFxuICBpbXBvcnRzOiBbXG4gIF0sXG4gIGV4cG9ydHM6IFtdXG59KVxuZXhwb3J0IGNsYXNzIE51Y2xldXNOb3RpZmljYXRpb25zTW9kdWxlIHtcblxuICBzdGF0aWMgZm9yUm9vdChjb25maWc6IE51Y2xldXNOb3RpZmljYXRpb25zQ29uZmlnKTogTW9kdWxlV2l0aFByb3ZpZGVyczxOdWNsZXVzTm90aWZpY2F0aW9uc01vZHVsZT4ge1xuICAgIHJldHVybiB7XG4gICAgICBuZ01vZHVsZTogTnVjbGV1c05vdGlmaWNhdGlvbnNNb2R1bGUsXG4gICAgICBwcm92aWRlcnM6IFtcbiAgICAgICAgeyBwcm92aWRlOiBOdWNsZXVzTm90aWZpY2F0aW9uc0NvbmZpZywgdXNlVmFsdWU6IGNvbmZpZyB9XG4gICAgICBdXG4gICAgfTtcbiAgfVxufVxuIl19

package/esm2022/lib/nucleus-notifications.service.mjs

@@ -0,0 +1,359 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { SwPush } from '@angular/service-worker';
+import { PushNotifications } from '@capacitor/push-notifications';
+import { NucleusAppService } from '@kolektor/nucleus-common';
+import { of, Subject } from 'rxjs';
+import { NucleusNotificationsConfig } from './models';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@angular/service-worker";
+import * as i3 from "@kolektor/nucleus-common";
+import * as i4 from "./models";
+export class NucleusNotificationsService {
+    constructor(http, swPush, appService, config) {
+        this.http = http;
+        this.swPush = swPush;
+        this.appService = appService;
+        this.registrationStorageKey = 'NucleusNotificationsRegistrationId';
+        this.notificationsStorageKey = 'NucleusNotificationsLocalCache';
+        this._isInitialized = false;
+        this._newNotifications = new Subject();
+        this._clicksSubject = new Subject();
+        this._stateChangesSubject = new Subject();
+        this.notifications = [];
+        let url = config.serverApiUrl;
+        if (!url.endsWith('/')) {
+            url += '/';
+        }
+        this.apiUrl = url;
+    }
+    get unreadCount() {
+        return this.notifications.filter(x => !x.isRead).length;
+    }
+    get newNotifications() {
+        return this._newNotifications.asObservable();
+    }
+    get clicks() {
+        return this._clicksSubject.asObservable();
+    }
+    get stateChanges() {
+        return this._stateChangesSubject.asObservable();
+    }
+    get isInitialized() {
+        return this._isInitialized;
+    }
+    async initialize() {
+        // make sure app service has finished initializing
+        await this.appService.init();
+        this.loadFromStorage();
+        if (this.appService.isNative) {
+            this._platform = this.appService.deviceInfo.platform;
+            await this.registerCapacitorEvents();
+        }
+        else if (this.swPush.isEnabled) {
+            this._platform = 'web';
+            this.registerWebPushEvents();
+        }
+        else {
+            console.warn('Nucleus.Notifications: There is no push capability, timer will be used to update notifications');
+            setInterval(() => {
+                console.log('Updating notifications...');
+                this.refresh(true);
+            }, 5 * 60 * 1000);
+        }
+        this._isInitialized = true;
+        this.refresh();
+    }
+    register() {
+        return new Promise((_resolve, _reject) => {
+            this.getRegistrationInfo().then((info) => {
+                this.http.post(this.apiUrl + 'registration', info).subscribe((regResult) => {
+                    window.localStorage.setItem(this.registrationStorageKey, regResult.id);
+                    _resolve(null);
+                }, error => {
+                    console.log('Nucleus.Notifications: Failed to send notification registration to server.', error);
+                    _reject(error);
+                });
+            }).catch((error) => _reject(error));
+        });
+    }
+    unregister() {
+        return new Promise((_resolve, _reject) => {
+            this.getRegistrationInfo().then((info) => {
+                this.http.request('DELETE', this.apiUrl + 'registration', { body: info }).subscribe(() => {
+                    window.localStorage.removeItem(this.registrationStorageKey);
+                    _resolve(null);
+                }, error => {
+                    console.log('Nucleus.Notifications: Failed to remove registration from server.', error);
+                    _reject(error);
+                });
+            }).catch((error) => _reject(error));
+        });
+    }
+    refresh(notifyAboutNew = false) {
+        this.http.get(this.apiUrl + 'notifications').subscribe(res => {
+            this.updateNotifications(res, notifyAboutNew);
+        });
+    }
+    getNotification(id) {
+        const localNotification = this.notifications.find(x => x.id === id);
+        if (localNotification) {
+            return of(localNotification);
+        }
+        return this.http.get(this.apiUrl + 'notifications/' + id);
+    }
+    readNotification(id) {
+        const n = this.notifications.find(x => x.id === id);
+        if (n && !n.isRead) {
+            n.isRead = true;
+            this.notifyStateChanged();
+        }
+        this.http.get(this.apiUrl + 'notifications/read/' + id).subscribe();
+    }
+    dismissNotification(id) {
+        this.deleteNotificaton(id);
+        this.http.delete(this.apiUrl + 'notifications/' + id).subscribe();
+        this.removeDeliveredNotification(id);
+    }
+    dismissAll() {
+        this.notifications.splice(0);
+        this.notifyStateChanged();
+        this.http.delete(this.apiUrl + 'notifications/all').subscribe();
+        if (this._platform === 'ios' || this._platform === 'android') {
+            PushNotifications.removeAllDeliveredNotifications();
+        }
+        else if (this._platform === 'web') {
+            // TODO: remove all web push notifications
+        }
+    }
+    readAll() {
+        for (const n of this.notifications) {
+            n.isRead = true;
+        }
+        this.notifyStateChanged();
+        this.http.get(this.apiUrl + 'notifications/read/all').subscribe();
+    }
+    getChannelConfig(senderId, channelId, language) {
+        return this.http.get(this.apiUrl + `settings/channel/${senderId}/${channelId}?language=${language}`);
+    }
+    getChannelConfigsForSender(senderId, channelIds, language) {
+        const idsStr = channelIds.map(x => senderId + ',' + x).join(';');
+        return this.getChannelConfigsInternal(idsStr, language);
+    }
+    getChannelConfigs(ids, language) {
+        const idsStr = ids.map(x => x.senderId + ',' + x.channelId).join(';');
+        return this.getChannelConfigsInternal(idsStr, language);
+    }
+    setChannelConfig(senderId, config) {
+        return this.http.post(`${this.apiUrl}settings/channel/${senderId}`, config);
+    }
+    setChannelConfigs(configs) {
+        return this.http.post(`${this.apiUrl}settings/channels`, configs);
+    }
+    getChannelConfigsInternal(ids, language) {
+        return this.http.get(`${this.apiUrl}settings/channels?ids=${ids}&language=${language}`);
+    }
+    updateNotifications(newNotifications, notifyAboutNew = false) {
+        let stateChanged = false;
+        for (const n of newNotifications) {
+            const existing = this.notifications.find(x => x.id === n.id);
+            if (existing) {
+                if (existing.isRead !== n.isRead) {
+                    existing.isRead = n.isRead;
+                    stateChanged = true;
+                }
+            }
+            else {
+                let i = 0;
+                while (i < this.notifications.length && n.dateCreated < this.notifications[i].dateCreated) {
+                    i++;
+                }
+                this.notifications.splice(i, 0, n);
+                stateChanged = true;
+                if (notifyAboutNew) {
+                    this._newNotifications.next(n);
+                }
+            }
+        }
+        const now = Date.now();
+        for (let i = this.notifications.length - 1; i >= 0; i--) {
+            const n = this.notifications[i];
+            if (new Date(n.expirationDate).getTime() < now || !newNotifications.find(x => x.id === n.id)) {
+                this.notifications.splice(i, 1);
+                stateChanged = true;
+            }
+        }
+        if (stateChanged) {
+            this.notifyStateChanged();
+        }
+    }
+    saveToStorage() {
+        const str = JSON.stringify(this.notifications);
+        window.localStorage.setItem(this.notificationsStorageKey, str);
+    }
+    loadFromStorage() {
+        try {
+            const str = window.localStorage.getItem(this.notificationsStorageKey);
+            if (str) {
+                const notifications = JSON.parse(str);
+                this.notifications = notifications.filter(x => !!x);
+                // precaution for notification.isRead of undefined error
+                this.notifyStateChanged(false);
+            }
+        }
+        catch { /* empty */ }
+    }
+    handleNotificationEvent(id, eventType) {
+        if (eventType.startsWith('new') || eventType === 'updated') { // we are handling new and newSilent
+            this.getNotification(id).subscribe(n => {
+                if (eventType.startsWith('new') && !n.isRead) {
+                    this._newNotifications.next(n);
+                }
+                const existing = this.notifications.find(x => x.id === n.id);
+                if (existing) {
+                    existing.isRead = n.isRead;
+                }
+                else {
+                    this.notifications.splice(0, 0, n);
+                }
+                this.notifyStateChanged();
+            });
+        }
+        else if (eventType === 'deleted') {
+            this.deleteNotificaton(id);
+        }
+        else {
+            this.refresh();
+        }
+    }
+    deleteNotificaton(id) {
+        const i = this.notifications.findIndex(x => x.id === id);
+        if (i >= 0) {
+            this.notifications.splice(i, 1);
+            this.notifyStateChanged();
+        }
+    }
+    notifyStateChanged(persistState = true) {
+        if (persistState) {
+            this.saveToStorage();
+        }
+        this._stateChangesSubject.next();
+    }
+    handleNotificationAction(notificationAction) {
+        if (!notificationAction) {
+            throw new Error('Notification action is empty!');
+        }
+        const arr = notificationAction.split(':');
+        const notificationClick = {
+            id: arr[0],
+            type: arr[1],
+            routerLink: arr[2]
+        };
+        const validNotificationClickTypes = ['default', 'deeplink'];
+        if (validNotificationClickTypes.includes(notificationClick.type)) {
+            this._clicksSubject.next(notificationClick);
+        }
+        else {
+            console.error(`Nucleus.Notifications: Unknown notification action: '${notificationAction}'.`);
+        }
+    }
+    removeDeliveredNotification(id) {
+        if (this._platform === 'ios' || this._platform === 'android') {
+            PushNotifications.getDeliveredNotifications().then(list => {
+                const toRemove = list.notifications.filter(n => {
+                    const data = this.getNotificationPayloadData(n);
+                    return (data.notificationId === id);
+                });
+                // TODO: On Android this does not currently work because notificationID is not set.
+                // This my solve the issue: https://github.com/ionic-team/capacitor/pull/3523
+                PushNotifications.removeDeliveredNotifications({
+                    notifications: toRemove
+                });
+            });
+        }
+        else if (this._platform === 'web') {
+            // TODO: remove web push notification
+        }
+    }
+    getNotificationPayloadData(pushNotification) {
+        return (this._platform === 'ios') ? pushNotification.data.data : pushNotification.data;
+    }
+    async registerCapacitorEvents() {
+        await PushNotifications.addListener('pushNotificationReceived', n => {
+            const data = this.getNotificationPayloadData(n);
+            console.log('Nucleus.Notifications: Received capacitor push event: ' + data.eventType, n);
+            this.handleNotificationEvent(data.notificationId, data.eventType);
+        });
+        await PushNotifications.addListener('pushNotificationActionPerformed', a => {
+            let action = a.notification.data.notificationAction;
+            if (this._platform === 'ios') {
+                action = a.notification.data.data.notificationAction;
+            }
+            console.log('Nucleus.Notifications: Received capacitor action event', action);
+            this.handleNotificationAction(action);
+        });
+    }
+    registerWebPushEvents() {
+        this.swPush.messages.subscribe((n) => {
+            const data = n.data;
+            console.log('Nucleus.Notifications: Received WebPush event: ' + data.eventType, n);
+            this.handleNotificationEvent(data.notificationId, data.eventType);
+        });
+        this.swPush.notificationClicks.subscribe((action) => {
+            console.log('Nucleus.Notifications: Received WebPush action event', action);
+            const tag = action.notification.tag;
+            this.handleNotificationAction(tag);
+        });
+    }
+    getRegistrationInfo() {
+        return new Promise((_resolve, _reject) => {
+            const registrationId = window.localStorage.getItem(this.registrationStorageKey);
+            if (this._platform === 'android' || this._platform === 'ios') {
+                // capacitor platform
+                const listener = PushNotifications.addListener('registration', token => {
+                    listener.remove();
+                    _resolve({ id: registrationId, token: token.value, platform: this._platform });
+                });
+                PushNotifications.register().catch(error => _reject('Could not register for notifications:' + error));
+            }
+            else if (this._platform === 'web') {
+                // Web Push API
+                this.http.get(this.apiUrl + 'registration/webkey').subscribe(key => {
+                    this.getWebPushSubscription(key.publicKey).then(subscription => {
+                        const t = JSON.stringify(subscription.toJSON());
+                        _resolve({ id: registrationId, token: t, platform: 'web' });
+                    });
+                }, error => _reject(error));
+            }
+            else {
+                _reject(`Nucleus.Notifications: Platform is not supported`);
+            }
+        });
+    }
+    getWebPushSubscription(publicKey) {
+        return new Promise((_resolve, _reject) => {
+            this.swPush.subscription.subscribe(subscription => {
+                if (subscription != null) {
+                    _resolve(subscription);
+                }
+                else {
+                    this.swPush.requestSubscription({ serverPublicKey: publicKey }).then(s => _resolve(s)).catch(e => _reject(e));
+                }
+            }, error => {
+                console.error('Nucleus.Notifications: Cannot get web push subscription', error);
+                _reject(error);
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusNotificationsService, deps: [{ token: i1.HttpClient }, { token: i2.SwPush }, { token: i3.NucleusAppService }, { token: i4.NucleusNotificationsConfig }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusNotificationsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NucleusNotificationsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.SwPush }, { type: i3.NucleusAppService }, { type: i4.NucleusNotificationsConfig }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nucleus-notifications.service.js","sourceRoot":"","sources":["../../../../../../libs/ng/nucleus-notifications/src/lib/nucleus-notifications.service.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAA0B,MAAM,+BAA+B,CAAC;AAC1F,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAc,EAAE,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/C,OAAO,EAML,0BAA0B,EAO3B,MAAM,UAAU,CAAC;;;;;;AAKlB,MAAM,OAAO,2BAA2B;IAEtC,YACU,IAAgB,EAChB,MAAc,EACd,UAA6B,EACrC,MAAkC;QAH1B,SAAI,GAAJ,IAAI,CAAY;QAChB,WAAM,GAAN,MAAM,CAAQ;QACd,eAAU,GAAV,UAAU,CAAmB;QAWtB,2BAAsB,GAAG,oCAAoC,CAAC;QAC9D,4BAAuB,GAAG,gCAAgC,CAAC;QAEpE,mBAAc,GAAG,KAAK,CAAC;QACvB,sBAAiB,GAAG,IAAI,OAAO,EAAgB,CAAC;QAChD,mBAAc,GAAG,IAAI,OAAO,EAAqB,CAAC;QAClD,yBAAoB,GAAG,IAAI,OAAO,EAAQ,CAAC;QAE5C,kBAAa,GAAmB,EAAE,CAAC;QAhBxC,IAAI,GAAG,GAAG,MAAM,CAAC,YAAY,CAAC;QAC9B,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;YACtB,GAAG,IAAI,GAAG,CAAC;SACZ;QACD,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC;IACpB,CAAC;IAaD,IAAW,WAAW;QACpB,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC;IAC1D,CAAC;IAED,IAAW,gBAAgB;QACzB,OAAO,IAAI,CAAC,iBAAiB,CAAC,YAAY,EAAE,CAAC;IAC/C,CAAC;IAED,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC;IAC5C,CAAC;IACD,IAAW,YAAY;QACrB,OAAO,IAAI,CAAC,oBAAoB,CAAC,YAAY,EAAE,CAAC;IAClD,CAAC;IAED,IAAW,aAAa;QACtB,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAEM,KAAK,CAAC,UAAU;QACrB,kDAAkD;QAClD,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;QAE7B,IAAI,CAAC,eAAe,EAAE,CAAC;QAEvB,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE;YAC5B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,QAAyB,CAAC;YACtE,MAAM,IAAI,CAAC,uBAAuB,EAAE,CAAC;SACtC;aAAM,IAAI,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE;YAChC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;YACvB,IAAI,CAAC,qBAAqB,EAAE,CAAC;SAC9B;aAAM;YACL,OAAO,CAAC,IAAI,CAAC,gGAAgG,CAAC,CAAC;YAC/G,WAAW,CAAC,GAAG,EAAE;gBACf,OAAO,CAAC,GAAG,CAAC,2BAA2B,CAAC,CAAC;gBACzC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YACrB,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;SACnB;QACD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC3B,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;IAEM,QAAQ;QACb,OAAO,IAAI,OAAO,CAAC,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE;YACvC,IAAI,CAAC,mBAAmB,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;gBACvC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAqB,IAAI,CAAC,MAAM,GAAG,cAAc,EAAE,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,EAAE,EAAE;oBAC7F,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,sBAAsB,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;oBACvE,QAAQ,CAAC,IAAI,CAAC,CAAC;gBACjB,CAAC,EAAE,KAAK,CAAC,EAAE;oBACT,OAAO,CAAC,GAAG,CAAC,4EAA4E,EAAE,KAAK,CAAC,CAAC;oBACjG,OAAO,CAAC,KAAK,CAAC,CAAC;gBACjB,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,UAAU;QACf,OAAO,IAAI,OAAO,CAAC,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE;YACvC,IAAI,CAAC,mBAAmB,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;gBACvC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAM,QAAQ,EAAE,IAAI,CAAC,MAAM,GAAG,cAAc,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;oBAC5F,MAAM,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;oBAC5D,QAAQ,CAAC,IAAI,CAAC,CAAC;gBACjB,CAAC,EAAE,KAAK,CAAC,EAAE;oBACT,OAAO,CAAC,GAAG,CAAC,mEAAmE,EAAE,KAAK,CAAC,CAAC;oBACxF,OAAO,CAAC,KAAK,CAAC,CAAC;gBACjB,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,OAAO,CAAC,cAAc,GAAG,KAAK;QACnC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAiB,IAAI,CAAC,MAAM,GAAG,eAAe,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;YAC3E,IAAI,CAAC,mBAAmB,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;QAChD,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,eAAe,CAAC,EAAU;QAC/B,MAAM,iBAAiB,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QACpE,IAAI,iBAAiB,EAAE;YACrB,OAAO,EAAE,CAAC,iBAAiB,CAAC,CAAC;SAC9B;QACD,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAe,IAAI,CAAC,MAAM,GAAG,gBAAgB,GAAG,EAAE,CAAC,CAAC;IAC1E,CAAC;IAEM,gBAAgB,CAAC,EAAU;QAChC,MAAM,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QACpD,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE;YAClB,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC;YAChB,IAAI,CAAC,kBAAkB,EAAE,CAAC;SAC3B;QACD,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,qBAAqB,GAAG,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC;IACtE,CAAC;IAEM,mBAAmB,CAAC,EAAU;QACnC,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;QAC3B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,GAAG,gBAAgB,GAAG,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC;QAClE,IAAI,CAAC,2BAA2B,CAAC,EAAE,CAAC,CAAC;IACvC,CAAC;IAEM,UAAU;QACf,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QAC7B,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC1B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,GAAG,mBAAmB,CAAC,CAAC,SAAS,EAAE,CAAC;QAChE,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS,EAAE;YAC5D,iBAAiB,CAAC,+BAA+B,EAAE,CAAC;SACrD;aAAM,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK,EAAE;YACnC,0CAA0C;SAC3C;IACH,CAAC;IAEM,OAAO;QACZ,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,aAAa,EAAE;YAClC,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC;SACjB;QACD,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC1B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,wBAAwB,CAAC,CAAC,SAAS,EAAE,CAAC;IACpE,CAAC;IAEM,gBAAgB,CAAC,QAAgB,EAAE,SAAiB,EAAE,QAAiB;QAC5E,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAoB,IAAI,CAAC,MAAM,GAAG,oBAAoB,QAAQ,IAAI,SAAS,aAAa,QAAQ,EAAE,CAAC,CAAC;IAC1H,CAAC;IAEM,0BAA0B,CAAC,QAAgB,EAAE,UAAoB,EAAE,QAAiB;QACzF,MAAM,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,QAAQ,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACjE,OAAO,IAAI,CAAC,yBAAyB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC1D,CAAC;IAEM,iBAAiB,CAAC,GAAgB,EAAE,QAAiB;QAC1D,MAAM,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAG,GAAG,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACtE,OAAO,IAAI,CAAC,yBAAyB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC1D,CAAC;IAEM,gBAAgB,CAAC,QAAgB,EAAE,MAAyB;QACjE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAO,GAAG,IAAI,CAAC,MAAM,oBAAoB,QAAQ,EAAE,EAAE,MAAM,CAAC,CAAC;IACpF,CAAC;IAEM,iBAAiB,CAAC,OAA4B;QACnD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAO,GAAG,IAAI,CAAC,MAAM,mBAAmB,EAAE,OAAO,CAAC,CAAC;IAC1E,CAAC;IAEO,yBAAyB,CAAC,GAAW,EAAE,QAAiB;QAC9D,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAsB,GAAG,IAAI,CAAC,MAAM,yBAAyB,GAAG,aAAa,QAAQ,EAAE,CAAC,CAAC;IAC/G,CAAC;IAEO,mBAAmB,CAAC,gBAAgC,EAAE,cAAc,GAAG,KAAK;QAClF,IAAI,YAAY,GAAG,KAAK,CAAC;QACzB,KAAK,MAAM,CAAC,IAAI,gBAAgB,EAAE;YAChC,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;YAC7D,IAAI,QAAQ,EAAE;gBACZ,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,EAAE;oBAChC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;oBAC3B,YAAY,GAAG,IAAI,CAAC;iBACrB;aACF;iBAAM;gBACL,IAAI,CAAC,GAAG,CAAC,CAAC;gBACV,OAAO,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,IAAI,CAAC,CAAC,WAAW,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE;oBACzF,CAAC,EAAE,CAAC;iBACL;gBACD,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;gBACnC,YAAY,GAAG,IAAI,CAAC;gBACpB,IAAI,cAAc,EAAE;oBAClB,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;iBAChC;aACF;SACF;QAED,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;YACvD,MAAM,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;YAChC,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,OAAO,EAAE,GAAG,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE;gBAC5F,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;gBAChC,YAAY,GAAG,IAAI,CAAC;aACrB;SACF;QAED,IAAI,YAAY,EAAE;YAChB,IAAI,CAAC,kBAAkB,EAAE,CAAC;SAC3B;IACH,CAAC;IAEO,aAAa;QACnB,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAC/C,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,uBAAuB,EAAE,GAAG,CAAC,CAAC;IACjE,CAAC;IAEO,eAAe;QACrB,IAAI;YACF,MAAM,GAAG,GAAG,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;YACtE,IAAI,GAAG,EAAE;gBACP,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAmB,CAAC;gBACxD,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACpD,wDAAwD;gBACxD,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;aAChC;SACF;QAAC,MAAM,EAAE,WAAW,EAAE;IACzB,CAAC;IAEO,uBAAuB,CAAC,EAAU,EAAE,SAAgC;QAC1E,IAAI,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,SAAS,KAAK,SAAS,EAAE,EAAE,oCAAoC;YAChG,IAAI,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;gBACrC,IAAI,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE;oBAC5C,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;iBAChC;gBACD,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;gBAC7D,IAAI,QAAQ,EAAE;oBACZ,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;iBAC5B;qBAAM;oBACL,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;iBACpC;gBACD,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC5B,CAAC,CAAC,CAAC;SACJ;aAAM,IAAI,SAAS,KAAK,SAAS,EAAE;YAClC,IAAI,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;SAC5B;aAAM;YACL,IAAI,CAAC,OAAO,EAAE,CAAC;SAChB;IACH,CAAC;IAEO,iBAAiB,CAAC,EAAU;QAClC,MAAM,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QACzD,IAAI,CAAC,IAAI,CAAC,EAAE;YACV,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YAChC,IAAI,CAAC,kBAAkB,EAAE,CAAC;SAC3B;IACH,CAAC;IAEO,kBAAkB,CAAC,YAAY,GAAG,IAAI;QAC5C,IAAI,YAAY,EAAE;YAChB,IAAI,CAAC,aAAa,EAAE,CAAC;SACtB;QACD,IAAI,CAAC,oBAAoB,CAAC,IAAI,EAAE,CAAC;IACnC,CAAC;IAEO,wBAAwB,CAAC,kBAAsC;QACrE,IAAI,CAAC,kBAAkB,EAAE;YACvB,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;SAClD;QAED,MAAM,GAAG,GAAG,kBAAkB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC1C,MAAM,iBAAiB,GAAsB;YAC3C,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC;YACV,IAAI,EAAE,GAAG,CAAC,CAAC,CAAqB;YAChC,UAAU,EAAE,GAAG,CAAC,CAAC,CAAC;SACnB,CAAC;QAEF,MAAM,2BAA2B,GAAG,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;QAC5D,IAAI,2BAA2B,CAAC,QAAQ,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE;YAChE,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;SAC7C;aAAM;YACL,OAAO,CAAC,KAAK,CAAC,wDAAwD,kBAAkB,IAAI,CAAC,CAAC;SAC/F;IACH,CAAC;IAEO,2BAA2B,CAAC,EAAU;QAC5C,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS,EAAE;YAC5D,iBAAiB,CAAC,yBAAyB,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;gBACxD,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE;oBAC7C,MAAM,IAAI,GAAG,IAAI,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC;oBAChD,OAAO,CAAC,IAAI,CAAC,cAAc,KAAK,EAAE,CAAC,CAAC;gBACtC,CAAC,CAAC,CAAC;gBAEH,mFAAmF;gBACnF,6EAA6E;gBAC7E,iBAAiB,CAAC,4BAA4B,CAAC;oBAC7C,aAAa,EAAE,QAAQ;iBACxB,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;SACJ;aAAM,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK,EAAE;YACnC,qCAAqC;SACtC;IACH,CAAC;IAEO,0BAA0B,CAAC,gBAAwC;QACzE,OAAO,CAAC,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC;IACzF,CAAC;IAEO,KAAK,CAAC,uBAAuB;QACnC,MAAM,iBAAiB,CAAC,WAAW,CAAC,0BAA0B,EAAE,CAAC,CAAC,EAAE;YAClE,MAAM,IAAI,GAAG,IAAI,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC;YAChD,OAAO,CAAC,GAAG,CAAC,wDAAwD,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;YAC1F,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QACpE,CAAC,CAAC,CAAC;QAEH,MAAM,iBAAiB,CAAC,WAAW,CAAC,iCAAiC,EAAE,CAAC,CAAC,EAAE;YACzE,IAAI,MAAM,GAAI,CAAS,CAAC,YAAY,CAAC,IAAI,CAAC,kBAAkB,CAAC;YAC7D,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK,EAAE;gBAC5B,MAAM,GAAI,CAAS,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC;aAC/D;YACD,OAAO,CAAC,GAAG,CAAC,wDAAwD,EAAE,MAAM,CAAC,CAAC;YAC9E,IAAI,CAAC,wBAAwB,CAAC,MAAM,CAAC,CAAC;QACxC,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,qBAAqB;QAC3B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE;YACnC,MAAM,IAAI,GAAiB,CAAS,CAAC,IAAI,CAAC;YAC1C,OAAO,CAAC,GAAG,CAAC,iDAAiD,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;YACnF,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QACpE,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,MAAM,EAAE,EAAE;YAClD,OAAO,CAAC,GAAG,CAAC,sDAAsD,EAAE,MAAM,CAAC,CAAC;YAC5E,MAAM,GAAG,GAAG,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC;YACpC,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,CAAC;QACrC,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,mBAAmB;QACzB,OAAO,IAAI,OAAO,CAAC,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE;YACvC,MAAM,cAAc,GAAG,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,sBAAsB,CAAW,CAAC;YAC1F,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK,EAAE;gBAC5D,qBAAqB;gBACrB,MAAM,QAAQ,GAAG,iBAAiB,CAAC,WAAW,CAAC,cAAc,EAAE,KAAK,CAAC,EAAE;oBACrE,QAAQ,CAAC,MAAM,EAAE,CAAC;oBAClB,QAAQ,CAAC,EAAE,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;gBACjF,CAAC,CAAC,CAAC;gBACH,iBAAiB,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,OAAO,CAAC,uCAAuC,GAAG,KAAK,CAAC,CAAC,CAAC;aACvG;iBAAM,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK,EAAE;gBACnC,eAAe;gBACf,IAAI,CAAC,IAAI,CAAC,GAAG,CAAS,IAAI,CAAC,MAAM,GAAG,qBAAqB,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE;oBACzE,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE;wBAC7D,MAAM,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC;wBAChD,QAAQ,CAAC,EAAE,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC;oBAC9D,CAAC,CAAC,CAAC;gBACL,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;aAC7B;iBAAM;gBACL,OAAO,CAAC,kDAAkD,CAAC,CAAC;aAC7D;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,sBAAsB,CAAC,SAAiB;QAC9C,OAAO,IAAI,OAAO,CAAC,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE;YACvC,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,YAAY,CAAC,EAAE;gBAChD,IAAI,YAAY,IAAI,IAAI,EAAE;oBACxB,QAAQ,CAAC,YAAY,CAAC,CAAC;iBACxB;qBAAM;oBACL,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC,EAAE,eAAe,EAAE,SAAS,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;iBAC/G;YACH,CAAC,EAAE,KAAK,CAAC,EAAE;gBACT,OAAO,CAAC,KAAK,CAAC,yDAAyD,EAAE,KAAK,CAAC,CAAC;gBAChF,OAAO,CAAC,KAAK,CAAC,CAAC;YACjB,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;+GAlXU,2BAA2B;mHAA3B,2BAA2B,cAF1B,MAAM;;4FAEP,2BAA2B;kBAHvC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { HttpClient } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { SwPush } from '@angular/service-worker';\nimport { PushNotifications, PushNotificationSchema } from '@capacitor/push-notifications';\nimport { NucleusAppService } from '@kolektor/nucleus-common';\nimport { Observable, of, Subject } from 'rxjs';\nimport {\n  ChannelId,\n  Notification,\n  NotificationClick,\n  NotificationEventType,\n  NotificationType,\n  NucleusNotificationsConfig,\n  PayloadData,\n  PlatformValue,\n  Registration,\n  RegistrationResult,\n  UserChannelConfig,\n  WebKey\n} from './models';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class NucleusNotificationsService {\n\n  constructor(\n    private http: HttpClient,\n    private swPush: SwPush,\n    private appService: NucleusAppService,\n    config: NucleusNotificationsConfig\n  ) {\n    let url = config.serverApiUrl;\n    if (!url.endsWith('/')) {\n      url += '/';\n    }\n    this.apiUrl = url;\n  }\n\n  private apiUrl: string;\n  private readonly registrationStorageKey = 'NucleusNotificationsRegistrationId';\n  private readonly notificationsStorageKey = 'NucleusNotificationsLocalCache';\n  private _platform: PlatformValue;\n  private _isInitialized = false;\n  private _newNotifications = new Subject<Notification>();\n  private _clicksSubject = new Subject<NotificationClick>();\n  private _stateChangesSubject = new Subject<void>();\n\n  public notifications: Notification[] = [];\n\n  public get unreadCount() {\n    return this.notifications.filter(x => !x.isRead).length;\n  }\n\n  public get newNotifications() {\n    return this._newNotifications.asObservable();\n  }\n\n  public get clicks() {\n    return this._clicksSubject.asObservable();\n  }\n  public get stateChanges() {\n    return this._stateChangesSubject.asObservable();\n  }\n\n  public get isInitialized() {\n    return this._isInitialized;\n  }\n\n  public async initialize() {\n    // make sure app service has finished initializing\n    await this.appService.init();\n\n    this.loadFromStorage();\n\n    if (this.appService.isNative) {\n      this._platform = this.appService.deviceInfo.platform as PlatformValue;\n      await this.registerCapacitorEvents();\n    } else if (this.swPush.isEnabled) {\n      this._platform = 'web';\n      this.registerWebPushEvents();\n    } else {\n      console.warn('Nucleus.Notifications: There is no push capability, timer will be used to update notifications');\n      setInterval(() => {\n        console.log('Updating notifications...');\n        this.refresh(true);\n      }, 5 * 60 * 1000);\n    }\n    this._isInitialized = true;\n    this.refresh();\n  }\n\n  public register(): Promise<any> {\n    return new Promise((_resolve, _reject) => {\n      this.getRegistrationInfo().then((info) => {\n        this.http.post<RegistrationResult>(this.apiUrl + 'registration', info).subscribe((regResult) => {\n          window.localStorage.setItem(this.registrationStorageKey, regResult.id);\n          _resolve(null);\n        }, error => {\n          console.log('Nucleus.Notifications: Failed to send notification registration to server.', error);\n          _reject(error);\n        });\n      }).catch((error) => _reject(error));\n    });\n  }\n\n  public unregister(): Promise<any> {\n    return new Promise((_resolve, _reject) => {\n      this.getRegistrationInfo().then((info) => {\n        this.http.request<any>('DELETE', this.apiUrl + 'registration', { body: info }).subscribe(() => {\n          window.localStorage.removeItem(this.registrationStorageKey);\n          _resolve(null);\n        }, error => {\n          console.log('Nucleus.Notifications: Failed to remove registration from server.', error);\n          _reject(error);\n        });\n      }).catch((error) => _reject(error));\n    });\n  }\n\n  public refresh(notifyAboutNew = false) {\n    this.http.get<Notification[]>(this.apiUrl + 'notifications').subscribe(res => {\n      this.updateNotifications(res, notifyAboutNew);\n    });\n  }\n\n  public getNotification(id: string): Observable<Notification> {\n    const localNotification = this.notifications.find(x => x.id === id);\n    if (localNotification) {\n      return of(localNotification);\n    }\n    return this.http.get<Notification>(this.apiUrl + 'notifications/' + id);\n  }\n\n  public readNotification(id: string) {\n    const n = this.notifications.find(x => x.id === id);\n    if (n && !n.isRead) {\n      n.isRead = true;\n      this.notifyStateChanged();\n    }\n    this.http.get(this.apiUrl + 'notifications/read/' + id).subscribe();\n  }\n\n  public dismissNotification(id: string) {\n    this.deleteNotificaton(id);\n    this.http.delete(this.apiUrl + 'notifications/' + id).subscribe();\n    this.removeDeliveredNotification(id);\n  }\n\n  public dismissAll() {\n    this.notifications.splice(0);\n    this.notifyStateChanged();\n    this.http.delete(this.apiUrl + 'notifications/all').subscribe();\n    if (this._platform === 'ios' || this._platform === 'android') {\n      PushNotifications.removeAllDeliveredNotifications();\n    } else if (this._platform === 'web') {\n      // TODO: remove all web push notifications\n    }\n  }\n\n  public readAll() {\n    for (const n of this.notifications) {\n      n.isRead = true;\n    }\n    this.notifyStateChanged();\n    this.http.get(this.apiUrl + 'notifications/read/all').subscribe();\n  }\n\n  public getChannelConfig(senderId: string, channelId: string, language?: string) {\n    return this.http.get<UserChannelConfig>(this.apiUrl + `settings/channel/${senderId}/${channelId}?language=${language}`);\n  }\n\n  public getChannelConfigsForSender(senderId: string, channelIds: string[], language?: string) {\n    const idsStr = channelIds.map(x => senderId + ',' + x).join(';');\n    return this.getChannelConfigsInternal(idsStr, language);\n  }\n\n  public getChannelConfigs(ids: ChannelId[], language?: string) {\n    const idsStr = ids.map(x => x.senderId + ',' + x.channelId).join(';');\n    return this.getChannelConfigsInternal(idsStr, language);\n  }\n\n  public setChannelConfig(senderId: string, config: UserChannelConfig) {\n    return this.http.post<void>(`${this.apiUrl}settings/channel/${senderId}`, config);\n  }\n\n  public setChannelConfigs(configs: UserChannelConfig[]) {\n    return this.http.post<void>(`${this.apiUrl}settings/channels`, configs);\n  }\n\n  private getChannelConfigsInternal(ids: string, language?: string) {\n    return this.http.get<UserChannelConfig[]>(`${this.apiUrl}settings/channels?ids=${ids}&language=${language}`);\n  }\n\n  private updateNotifications(newNotifications: Notification[], notifyAboutNew = false) {\n    let stateChanged = false;\n    for (const n of newNotifications) {\n      const existing = this.notifications.find(x => x.id === n.id);\n      if (existing) {\n        if (existing.isRead !== n.isRead) {\n          existing.isRead = n.isRead;\n          stateChanged = true;\n        }\n      } else {\n        let i = 0;\n        while (i < this.notifications.length && n.dateCreated < this.notifications[i].dateCreated) {\n          i++;\n        }\n        this.notifications.splice(i, 0, n);\n        stateChanged = true;\n        if (notifyAboutNew) {\n          this._newNotifications.next(n);\n        }\n      }\n    }\n\n    const now = Date.now();\n    for (let i = this.notifications.length - 1; i >= 0; i--) {\n      const n = this.notifications[i];\n      if (new Date(n.expirationDate).getTime() < now || !newNotifications.find(x => x.id === n.id)) {\n        this.notifications.splice(i, 1);\n        stateChanged = true;\n      }\n    }\n\n    if (stateChanged) {\n      this.notifyStateChanged();\n    }\n  }\n\n  private saveToStorage() {\n    const str = JSON.stringify(this.notifications);\n    window.localStorage.setItem(this.notificationsStorageKey, str);\n  }\n\n  private loadFromStorage() {\n    try {\n      const str = window.localStorage.getItem(this.notificationsStorageKey);\n      if (str) {\n        const notifications = JSON.parse(str) as Notification[];\n        this.notifications = notifications.filter(x => !!x);\n        // precaution for notification.isRead of undefined error\n        this.notifyStateChanged(false);\n      }\n    } catch { /* empty */ }\n  }\n\n  private handleNotificationEvent(id: string, eventType: NotificationEventType) {\n    if (eventType.startsWith('new') || eventType === 'updated') { // we are handling new and newSilent\n      this.getNotification(id).subscribe(n => {\n        if (eventType.startsWith('new') && !n.isRead) {\n          this._newNotifications.next(n);\n        }\n        const existing = this.notifications.find(x => x.id === n.id);\n        if (existing) {\n          existing.isRead = n.isRead;\n        } else {\n          this.notifications.splice(0, 0, n);\n        }\n        this.notifyStateChanged();\n      });\n    } else if (eventType === 'deleted') {\n      this.deleteNotificaton(id);\n    } else {\n      this.refresh();\n    }\n  }\n\n  private deleteNotificaton(id: string) {\n    const i = this.notifications.findIndex(x => x.id === id);\n    if (i >= 0) {\n      this.notifications.splice(i, 1);\n      this.notifyStateChanged();\n    }\n  }\n\n  private notifyStateChanged(persistState = true) {\n    if (persistState) {\n      this.saveToStorage();\n    }\n    this._stateChangesSubject.next();\n  }\n\n  private handleNotificationAction(notificationAction: string | undefined) {\n    if (!notificationAction) {\n      throw new Error('Notification action is empty!');\n    }\n\n    const arr = notificationAction.split(':');\n    const notificationClick: NotificationClick = {\n      id: arr[0],\n      type: arr[1] as NotificationType,\n      routerLink: arr[2]\n    };\n\n    const validNotificationClickTypes = ['default', 'deeplink'];\n    if (validNotificationClickTypes.includes(notificationClick.type)) {\n      this._clicksSubject.next(notificationClick);\n    } else {\n      console.error(`Nucleus.Notifications: Unknown notification action: '${notificationAction}'.`);\n    }\n  }\n\n  private removeDeliveredNotification(id: string) {\n    if (this._platform === 'ios' || this._platform === 'android') {\n      PushNotifications.getDeliveredNotifications().then(list => {\n        const toRemove = list.notifications.filter(n => {\n          const data = this.getNotificationPayloadData(n);\n          return (data.notificationId === id);\n        });\n\n        // TODO: On Android this does not currently work because notificationID is not set.\n        // This my solve the issue: https://github.com/ionic-team/capacitor/pull/3523\n        PushNotifications.removeDeliveredNotifications({\n          notifications: toRemove\n        });\n      });\n    } else if (this._platform === 'web') {\n      // TODO: remove web push notification\n    }\n  }\n\n  private getNotificationPayloadData(pushNotification: PushNotificationSchema): PayloadData {\n    return (this._platform === 'ios') ? pushNotification.data.data : pushNotification.data;\n  }\n\n  private async registerCapacitorEvents() {\n    await PushNotifications.addListener('pushNotificationReceived', n => {\n      const data = this.getNotificationPayloadData(n);\n      console.log('Nucleus.Notifications: Received capacitor push event: ' + data.eventType, n);\n      this.handleNotificationEvent(data.notificationId, data.eventType);\n    });\n\n    await PushNotifications.addListener('pushNotificationActionPerformed', a => {\n      let action = (a as any).notification.data.notificationAction;\n      if (this._platform === 'ios') {\n        action = (a as any).notification.data.data.notificationAction;\n      }\n      console.log('Nucleus.Notifications: Received capacitor action event', action);\n      this.handleNotificationAction(action);\n    });\n  }\n\n  private registerWebPushEvents() {\n    this.swPush.messages.subscribe((n) => {\n      const data: PayloadData = (n as any).data;\n      console.log('Nucleus.Notifications: Received WebPush event: ' + data.eventType, n);\n      this.handleNotificationEvent(data.notificationId, data.eventType);\n    });\n\n    this.swPush.notificationClicks.subscribe((action) => {\n      console.log('Nucleus.Notifications: Received WebPush action event', action);\n      const tag = action.notification.tag;\n      this.handleNotificationAction(tag);\n    });\n  }\n\n  private getRegistrationInfo(): Promise<Registration> {\n    return new Promise((_resolve, _reject) => {\n      const registrationId = window.localStorage.getItem(this.registrationStorageKey) as string;\n      if (this._platform === 'android' || this._platform === 'ios') {\n        // capacitor platform\n        const listener = PushNotifications.addListener('registration', token => {\n          listener.remove();\n          _resolve({ id: registrationId, token: token.value, platform: this._platform });\n        });\n        PushNotifications.register().catch(error => _reject('Could not register for notifications:' + error));\n      } else if (this._platform === 'web') {\n        // Web Push API\n        this.http.get<WebKey>(this.apiUrl + 'registration/webkey').subscribe(key => {\n          this.getWebPushSubscription(key.publicKey).then(subscription => {\n            const t = JSON.stringify(subscription.toJSON());\n            _resolve({ id: registrationId, token: t, platform: 'web' });\n          });\n        }, error => _reject(error));\n      } else {\n        _reject(`Nucleus.Notifications: Platform is not supported`);\n      }\n    });\n  }\n\n  private getWebPushSubscription(publicKey: string): Promise<PushSubscription> {\n    return new Promise((_resolve, _reject) => {\n      this.swPush.subscription.subscribe(subscription => {\n        if (subscription != null) {\n          _resolve(subscription);\n        } else {\n          this.swPush.requestSubscription({ serverPublicKey: publicKey }).then(s => _resolve(s)).catch(e => _reject(e));\n        }\n      }, error => {\n        console.error('Nucleus.Notifications: Cannot get web push subscription', error);\n        _reject(error);\n      });\n    });\n  }\n}\n"]}