@seniorsistemas/platform-components 5.3.2 → 5.3.3-develop-73308358

package/esm2022/modules/permissions/permissions.module.mjs

@@ -0,0 +1,43 @@
+import { NgModule } from '@angular/core';
+import { RESOURCES, ENVIRONMENT } from './permissions.config';
+import { PermissionsService } from './permissions.service';
+import * as i0 from "@angular/core";
+export class PermissionsModule {
+    static forRoot(resources, environment) {
+        return {
+            ngModule: PermissionsModule,
+            providers: [
+                PermissionsService,
+                {
+                    provide: RESOURCES,
+                    multi: true,
+                    useValue: resources
+                },
+                {
+                    provide: ENVIRONMENT,
+                    multi: false,
+                    useValue: environment
+                }
+            ]
+        };
+    }
+    static forChild(resources) {
+        return {
+            ngModule: PermissionsModule,
+            providers: [
+                {
+                    provide: RESOURCES,
+                    multi: true,
+                    useValue: resources
+                }
+            ]
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PermissionsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: PermissionsModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PermissionsModule });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PermissionsModule, decorators: [{
+            type: NgModule
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/modules/permissions/permissions.service.mjs

@@ -0,0 +1,169 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable, inject } from '@angular/core';
+import { Router } from '@angular/router';
+import { TranslateService } from '@ngx-translate/core';
+import { ToastService } from "@seniorsistemas/angular-components/toast";
+import { from, of, throwError } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { ENVIRONMENT, RESOURCES } from './permissions.config';
+import * as i0 from "@angular/core";
+export let promise;
+export class PermissionsService {
+    resources = inject(RESOURCES);
+    environment = inject(ENVIRONMENT);
+    http = inject(HttpClient);
+    router = inject(Router);
+    toastService = inject(ToastService);
+    translate = inject(TranslateService);
+    checkedPermissions = {};
+    actionUrl = 'platform/authorization/queries';
+    // v2
+    checkAccess(resources) {
+        const permissions = [];
+        resources.forEach(rec => {
+            rec.actions.forEach(action => {
+                if (!rec.uri) {
+                    rec.uri = this.getUriByResourceName(rec.name, rec.entity);
+                }
+                permissions.push({ action, resource: rec.uri });
+            });
+        });
+        return this.http.post(`${this.actionUrl}/checkAccess`, { includeFilters: true, permissions }).pipe(map((response) => {
+            const checkedPermissions = response.permissions || response;
+            this.checkedPermissions = { ...this.checkedPermissions, ...checkedPermissions };
+            const values = {};
+            if (this.shouldRedirectToForbiddenPage(resources, checkedPermissions)) {
+                this.router.navigate(['error', 403]);
+                return throwError(() => new Error('forbidden'));
+            }
+            checkedPermissions.forEach((permission) => {
+                const resource = resources.find(res => res.uri === permission.resource);
+                if (!resource) {
+                    return;
+                }
+                const { name } = resource;
+                values[name] = values[name] || {};
+                values[name][permission.action] = permission.authorized;
+                values[name][permission.action.toLowerCase()] = permission.authorized;
+                if (permission.resourceFilters?.length) {
+                    values[name]['resourceFilters'] = [
+                        ...(values[name]['resourceFilters'] || []),
+                        ...permission.resourceFilters
+                    ];
+                }
+            });
+            return values;
+        }));
+    }
+    // v1
+    get(resource = '') {
+        if (!promise) {
+            promise = this.getPermissions();
+        }
+        return from(promise).pipe(map((permissions) => {
+            this.checkedPermissions = permissions;
+            if (resource) {
+                const resourceKey = Object.keys(permissions)
+                    .find(key => key.toLowerCase() === resource.toLowerCase());
+                return permissions[resourceKey];
+            }
+            return permissions;
+        }), catchError(() => {
+            promise = undefined;
+            this.toastService.show({
+                severity: 'error',
+                title: this.translate.instant('permission_error_summary'),
+                text: this.translate.instant('permission_error_detail')
+            });
+            return of(this.getPermissionObject(false));
+        }));
+    }
+    isAuthorized(resourceName, action, isEntity) {
+        if (!this.checkedPermissions || Object.keys(this.checkedPermissions).length === 0) {
+            throwError(() => new Error('\'Permissions\' are not defined. You should call \'get\' or \'checkAccess\' method first.'));
+        }
+        const resourceKey = Object.keys(this.checkedPermissions)
+            .find(key => key.toLowerCase() === resourceName.toLowerCase());
+        if (!resourceKey) {
+            return false;
+        }
+        const actions = this.checkedPermissions[resourceKey];
+        return actions?.[action] ?? actions?.[action.toLowerCase()] ?? false;
+    }
+    getUriByResourceName(resourceName, isEntity) {
+        const { domain, service } = this.environment;
+        if (!domain || !service) {
+            throwError(() => new Error('You must inform domain and service name'));
+        }
+        const uriBase = `res://senior.com.br/${domain}/${service}`;
+        return isEntity ? `${uriBase}/entities/${resourceName}` : `${uriBase}/${resourceName}`;
+    }
+    shouldRedirectToForbiddenPage(resources = [], permissions) {
+        const permissionsDenied = permissions.filter(perm => !perm.authorized);
+        if (permissionsDenied.length) {
+            const resourcesToCheck = resources.filter(r => r.redirectToError);
+            if (resourcesToCheck.length) {
+                return resourcesToCheck.every(resource => {
+                    const actionsToCheck = resource.actionsToCheck?.length ? resource.actionsToCheck : resource.actions;
+                    return actionsToCheck.every(action => permissionsDenied.some(p => p.resource === resource.uri && p.action === action));
+                });
+            }
+        }
+        return false;
+    }
+    getFlatEnvironment() {
+        return this.environment.ignorePermissions;
+    }
+    getFlatResources() {
+        return this.resources.reduce((result, item) => {
+            if (!item) {
+                return result;
+            }
+            return Array.isArray(item) ? [...result, ...item] : [...result, item];
+        }, []);
+    }
+    getPermissionObject(defaultValue) {
+        return this.getFlatResources().reduce((resources, resource) => {
+            resources[resource.name] = resource.actions.reduce((actions, action) => {
+                actions[action] = defaultValue;
+                actions[action.toLowerCase()] = defaultValue;
+                return actions;
+            }, {});
+            return resources;
+        }, {});
+    }
+    async getPermissions() {
+        if (this.getFlatEnvironment()) {
+            return this.getPermissionObject(true);
+        }
+        const resources = this.getFlatResources();
+        const perm = resources
+            .map(resource => resource.actions.map((action) => ({ action, resource: resource.uri })))
+            .reduce((acc, val) => [...acc, ...val]);
+        const response = await this.http
+            .post(`${this.actionUrl}/checkAccess`, { includeFilters: false, permissions: perm })
+            .toPromise();
+        const permissions = response.permissions ?? response;
+        const values = {};
+        permissions.forEach((permission) => {
+            const resource = resources.find((res) => res.uri === permission.resource);
+            if (!resource) {
+                return;
+            }
+            const { name } = resource;
+            values[name] = values[name] || {};
+            values[name][permission.action] = permission.authorized;
+            values[name][permission.action.toLowerCase()] = permission.authorized;
+        });
+        return values;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PermissionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PermissionsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PermissionsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permissions.service.js","sourceRoot":"","sources":["../../../../lib/src/modules/permissions/permissions.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Injectable, inject } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { TranslateService } from '@ngx-translate/core';\nimport { ToastService } from \"@seniorsistemas/angular-components/toast\";\nimport { from, Observable, of, throwError } from 'rxjs';\nimport { catchError, map } from 'rxjs/operators';\nimport {\n  Environment,\n  ENVIRONMENT,\n  Permission,\n  Resource,\n  Resources,\n  RESOURCES\n} from './permissions.config';\n\nexport let promise: Promise<any>;\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class PermissionsService {\n  private readonly resources = inject<Resources>(RESOURCES);\n  private readonly environment = inject<Environment>(ENVIRONMENT);\n  private readonly http = inject(HttpClient);\n  private readonly router = inject(Router);\n  private readonly toastService = inject(ToastService);\n  private readonly translate = inject(TranslateService);\n\n  private checkedPermissions: any = {};\n  private readonly actionUrl = 'platform/authorization/queries';\n\n  // v2\n  checkAccess(resources: Resource[]): Observable<any> {\n    const permissions: any[] = [];\n\n    resources.forEach(rec => {\n      rec.actions.forEach(action => {\n        if (!rec.uri) {\n          rec.uri = this.getUriByResourceName(rec.name, rec.entity);\n        }\n        permissions.push({ action, resource: rec.uri });\n      });\n    });\n\n    return this.http.post(`${this.actionUrl}/checkAccess`, { includeFilters: true, permissions }).pipe(\n      map((response: any) => {\n        const checkedPermissions = response.permissions || response;\n\n        this.checkedPermissions = { ...this.checkedPermissions, ...checkedPermissions };\n\n        const values: any = {};\n\n        if (this.shouldRedirectToForbiddenPage(resources, checkedPermissions)) {\n          this.router.navigate(['error', 403]);\n          return throwError(() => new Error('forbidden'));\n        }\n\n        checkedPermissions.forEach((permission: any) => {\n          const resource = resources.find(res => res.uri === permission.resource);\n\n          if (!resource) {\n            return;\n          }\n\n          const { name } = resource;\n\n          values[name] = values[name] || {};\n          values[name][permission.action] = permission.authorized;\n          values[name][permission.action.toLowerCase()] = permission.authorized;\n\n          if (permission.resourceFilters?.length) {\n            values[name]['resourceFilters'] = [\n              ...(values[name]['resourceFilters'] || []),\n              ...permission.resourceFilters\n            ];\n          }\n        });\n\n        return values;\n      })\n    );\n  }\n\n  // v1\n  get(resource: string = '') {\n    if (!promise) {\n      promise = this.getPermissions();\n    }\n\n    return from(promise).pipe(\n      map((permissions: any) => {\n        this.checkedPermissions = permissions;\n\n        if (resource) {\n          const resourceKey = Object.keys(permissions)\n            .find(key => key.toLowerCase() === resource.toLowerCase());\n          return permissions[resourceKey];\n        }\n\n        return permissions;\n      }),\n      catchError(() => {\n        promise = undefined;\n        this.toastService.show({\n          severity: 'error',\n          title: this.translate.instant('permission_error_summary'),\n          text: this.translate.instant('permission_error_detail')\n        });\n\n        return of(this.getPermissionObject(false));\n      })\n    );\n  }\n\n  isAuthorized(resourceName: string, action: string, isEntity?: boolean): boolean {\n    if (!this.checkedPermissions || Object.keys(this.checkedPermissions).length === 0) {\n      throwError(() => new Error('\\'Permissions\\' are not defined. You should call \\'get\\' or \\'checkAccess\\' method first.'));\n    }\n\n    const resourceKey = Object.keys(this.checkedPermissions)\n      .find(key => key.toLowerCase() === resourceName.toLowerCase());\n\n    if (!resourceKey) {\n      return false;\n    }\n\n    const actions = this.checkedPermissions[resourceKey];\n    return actions?.[action] ?? actions?.[action.toLowerCase()] ?? false;\n  }\n\n  private getUriByResourceName(resourceName: string, isEntity?: boolean): string {\n    const { domain, service } = this.environment;\n\n    if (!domain || !service) {\n      throwError(() => new Error('You must inform domain and service name'));\n    }\n\n    const uriBase = `res://senior.com.br/${domain}/${service}`;\n    return isEntity ? `${uriBase}/entities/${resourceName}` : `${uriBase}/${resourceName}`;\n  }\n\n  private shouldRedirectToForbiddenPage(resources: Resource[] = [], permissions: Permission[]): boolean {\n    const permissionsDenied = permissions.filter(perm => !perm.authorized);\n\n    if (permissionsDenied.length) {\n      const resourcesToCheck = resources.filter(r => r.redirectToError);\n      if (resourcesToCheck.length) {\n        return resourcesToCheck.every(resource => {\n          const actionsToCheck = resource.actionsToCheck?.length ? resource.actionsToCheck : resource.actions;\n          return actionsToCheck.every(action =>\n            permissionsDenied.some(p => p.resource === resource.uri && p.action === action)\n          );\n        });\n      }\n    }\n    return false;\n  }\n\n  private getFlatEnvironment() {\n    return this.environment.ignorePermissions;\n  }\n\n  private getFlatResources() {\n    return this.resources.reduce((result: Resource[], item: any) => {\n\n      if (!item) {\n        return result;\n      }\n\n      return Array.isArray(item) ? [...result, ...item] : [...result, item];\n    }, []);\n  }\n\n  private getPermissionObject(defaultValue: boolean) {\n    return this.getFlatResources().reduce((resources: any, resource: Resource) => {\n      resources[resource.name] = resource.actions.reduce((actions: any, action: any) => {\n        actions[action] = defaultValue;\n        actions[action.toLowerCase()] = defaultValue;\n        return actions;\n      }, {});\n      return resources;\n    }, {});\n  }\n\n  private async getPermissions() {\n    if (this.getFlatEnvironment()) {\n      return this.getPermissionObject(true);\n    }\n\n    const resources = this.getFlatResources();\n    const perm = resources\n      .map(resource => resource.actions.map((action: any) => ({ action, resource: resource.uri })))\n      .reduce((acc: any, val: any) => [...acc, ...val]);\n\n    const response: any = await this.http\n      .post(`${this.actionUrl}/checkAccess`, { includeFilters: false, permissions: perm })\n      .toPromise();\n\n    const permissions = response.permissions ?? response;\n    const values: any = {};\n\n    permissions.forEach((permission: any) => {\n      const resource = resources.find((res: any) => res.uri === permission.resource);\n      if (!resource) {\n        return;\n      }\n\n      const { name } = resource;\n      values[name] = values[name] || {};\n      values[name][permission.action] = permission.authorized;\n      values[name][permission.action.toLowerCase()] = permission.authorized;\n    });\n\n    return values;\n  }\n}\n"]}

package/esm2022/modules/spotlight/component/spotlight.component.mjs

@@ -0,0 +1,274 @@
+import { UserAction } from './../models/user-action.enum';
+import { Component, EventEmitter, Input, Output, inject } from '@angular/core';
+import { SpotlightService } from '../service/spotlight.service';
+import { EnumDisplayType, EnumSpotlightStatus } from '../models/index';
+import { DatePipe } from '@angular/common';
+import { CookieService } from 'ngx-cookie-service';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/button";
+import * as i2 from "primeng/tooltip";
+import * as i3 from "@angular/common";
+import * as i4 from "../pipes/translate.pipe";
+export class SpotlightComponent {
+    spotlightService = inject(SpotlightService);
+    cookieService = inject(CookieService);
+    datePipe = inject(DatePipe);
+    header;
+    imgUrl;
+    primaryButtonLabel;
+    primaryButtonTooltip;
+    canAppear = false;
+    currentUser;
+    spotlightUsersList;
+    spotlightControlsList;
+    spotlightScreen;
+    canEmitEvent;
+    visible = false;
+    menuId;
+    fade = false;
+    visibleChange = new EventEmitter();
+    async ngOnInit() {
+        await this.setValues();
+        this.fetchSpotlight();
+    }
+    async setValues() {
+        const userData = JSON.parse(this.cookieService.get('com.senior.token'));
+        this.currentUser = userData.username;
+        this.spotlightUsersList = await this.spotlightService.listSpotlightUsers();
+        this.spotlightControlsList = await this.spotlightService.listSpotlightControl();
+    }
+    setValuesInSpotlight(values) {
+        this.header = values.spotlightTitle;
+        this.imgUrl = values.bannerUrl;
+        this.primaryButtonLabel = values.primaryButtonLabel;
+        this.primaryButtonTooltip = values.primaryButtonHint;
+    }
+    getShowDate(days) {
+        const currentDate = new Date();
+        return this.datePipe.transform(currentDate.setDate(currentDate.getDate() + days).toString(), 'yyyy-MM-dd');
+    }
+    fetchSpotlight() {
+        this.spotlightService.listSpotlightScreen().subscribe(value => {
+            this.spotlightScreen = value.contents.filter(val => val.screenMenuId === this.menuId)[0];
+            if (this.spotlightScreen) {
+                this.showSpotlight(this.spotlightScreen.spotlight);
+            }
+        });
+    }
+    showSpotlight(spotlight) {
+        if (this.validateDate(spotlight.initialDate) && this.validateFinalDate(spotlight.finalDate) && this.validateSpotlight(spotlight)) {
+            this.setValuesInSpotlight(spotlight);
+            this.canAppear = true;
+            const control = this.getSpotlightControlFromList(this.spotlightScreen.spotlight.id);
+            this.canEmitEvent = !control || this.currentUser !== control.firstUser;
+        }
+    }
+    validateDate(date) {
+        if (date) {
+            const currentDate = this.datePipe.transform(new Date().toString(), 'yyyy-MM-dd');
+            const initialDate = this.datePipe.transform(date, 'yyyy-MM-dd');
+            return currentDate >= initialDate;
+        }
+        return false;
+    }
+    validateFinalDate(date) {
+        if (date) {
+            const currentDate = this.datePipe.transform(new Date().toString(), 'yyyy-MM-dd');
+            const finalDate = this.datePipe.transform(date, 'yyyy-MM-dd');
+            return currentDate <= finalDate;
+        }
+        return true;
+    }
+    validateSpotlight(spotlight) {
+        if (!this.validateControlsList(this.spotlightControlsList, spotlight, this.currentUser)) {
+            return false;
+        }
+        if (!this.validateDisplayType(spotlight, this.spotlightUsersList, this.spotlightControlsList, this.currentUser)) {
+            return false;
+        }
+        return true;
+    }
+    validateControlsList(controlsList, spotlight, currentUser) {
+        if (controlsList.totalElements) {
+            const notCompatibleControls = controlsList.contents.filter(control => {
+                if (control.status === EnumSpotlightStatus.ACTIVE) {
+                    return control.spotlightId === spotlight.id;
+                }
+                else if (control.status === EnumSpotlightStatus.IN_PROGRESS) {
+                    return control.spotlightId === spotlight.id && control.firstUser !== currentUser;
+                }
+            });
+            if (notCompatibleControls.length > 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    validateDisplayType(spotlight, usersList, controlsList, currentUser) {
+        switch (spotlight.displayType) {
+            case EnumDisplayType.ADVERSITING:
+                return usersList.totalElements ? this.validateUser(usersList.contents, spotlight) : true;
+            case EnumDisplayType.INTEGRATION:
+                if (controlsList.totalElements) {
+                    const compatibleControls = controlsList.contents.filter(control => {
+                        switch (control.status) {
+                            case EnumSpotlightStatus.NO_STARTED:
+                                return control.spotlightId === spotlight.id;
+                            case EnumSpotlightStatus.REFUSED:
+                                return usersList.totalElements ? this.validateUser(usersList.contents, spotlight) : true;
+                            case EnumSpotlightStatus.IN_PROGRESS:
+                                return control.firstUser === currentUser
+                                    && control.spotlightId === spotlight.id;
+                        }
+                    });
+                    if (compatibleControls.length === 0) {
+                        return false;
+                    }
+                }
+                return true;
+        }
+    }
+    validateUser(users, spotlight) {
+        let spotlightUsers = users.filter(user => user.spotlightId === spotlight.id);
+        if (!spotlightUsers.length) {
+            spotlightUsers = users.filter(user => user.userOperation === this.currentUser);
+            return spotlightUsers.length === 0;
+        }
+        const compatibleUserToValidate = spotlightUsers.filter(user => user.userOperation === this.currentUser)[0];
+        return compatibleUserToValidate ? this.validateDate(compatibleUserToValidate.showDate) : true;
+    }
+    saveSpotlightUser(days) {
+        const spotlight = this.spotlightScreen.spotlight;
+        const user = this.spotlightUsersList.contents.filter(val => {
+            return val.spotlightId === spotlight.id
+                && val.userOperation === this.currentUser;
+        })[0];
+        let spotlightUser = {
+            spotlightId: spotlight.id,
+            showDate: days ? this.getShowDate(days) : null,
+            userOperation: this.currentUser
+        };
+        if (user) {
+            spotlightUser = {
+                id: user.id,
+                ...spotlightUser
+            };
+        }
+        this.spotlightService.saveSpotlightUser(spotlightUser).subscribe();
+    }
+    onPrimary() {
+        const spotlight = this.spotlightScreen.spotlight;
+        const notification = this.buildNotification(UserAction.CONFIRMED);
+        this.saveSpotlightControl();
+        this.saveSpotlightUser();
+        if (this.canEmitEvent) {
+            this.spotlightService.notificateSpotlight(notification).subscribe();
+        }
+        if (spotlight.primaryButtonUrl) {
+            window.open(spotlight.primaryButtonUrl);
+        }
+        this.close();
+    }
+    onSecondary() {
+        const notification = this.buildNotification(UserAction.POSTPONED);
+        this.saveSpotlightControl(EnumSpotlightStatus.REFUSED);
+        this.saveSpotlightUser(this.spotlightScreen.spotlight.daysRememberLate);
+        this.spotlightService.notificateSpotlight(notification).subscribe();
+        this.close();
+    }
+    onTertiary() {
+        const notification = this.buildNotification(UserAction.REFUSED);
+        this.saveSpotlightControl(EnumSpotlightStatus.REFUSED);
+        this.saveSpotlightUser(this.spotlightScreen.spotlight.daysNotInterested);
+        this.spotlightService.notificateSpotlight(notification).subscribe();
+        this.close();
+    }
+    /**
+     * Verifica se um registro de usuário pertence ao usuário logado e corresponde ao spotlight atual
+     * @param user SpotlightUser Objeto representando o registro do usuário para uma spotlight
+     * @param spotlight Spotlight Spotlight
+     * @returns boolean true se corresponder ao spotlight atual, false caso contrário
+     */
+    hasThisRegister(user, spotlight) {
+        return (user.spotlightId === spotlight.id && user.userOperation === this.currentUser);
+    }
+    /**
+     * Verifica se um registro de usuário pertece ao usuário logado, mas não corresponde ao spotlight atual
+     * @param user SpotlightUser Objeto representando o registro do usuário para uma spotlight
+     * @param spotlight Spotlight Spotlight
+     * @returns boolean true se corresponder ao spotlight atual, false caso contrário
+     */
+    hasAnotherRegister(user, spotlight) {
+        return user.spotlightId !== spotlight.id && user.userOperation === this.currentUser;
+    }
+    /**
+     * Persiste um novo registro de controle para o spotlight atual se
+     * não for encontrado nenhum na lista de controles carregada inicialmente
+     * @param status EnumSpotlightStatus Status do controle do spotlight. Se nenhum for informado, IN_PROGRESS será aplicado
+     * @returns SpotlightControl Controle do spotlight recuperado/pesistido
+     */
+    saveSpotlightControl(status = EnumSpotlightStatus.IN_PROGRESS) {
+        const spotlight = this.spotlightScreen.spotlight;
+        let control = this.getSpotlightControlFromList(spotlight.id);
+        if (!control) {
+            control = {
+                spotlightId: spotlight.id,
+                status: status,
+                firstUser: this.currentUser
+            };
+        }
+        if (this.isNewControl(control) || control.status !== EnumSpotlightStatus.IN_PROGRESS) {
+            control.status = status;
+            control.firstUser = status === EnumSpotlightStatus.IN_PROGRESS ? this.currentUser : '';
+            this.spotlightService.saveSpotlightControl(control).subscribe();
+        }
+        return control;
+    }
+    /**
+     * Retorna o controle de spotlight correspondente ao identificador
+     * informado na lista de controles carregada na inicialização do componente
+     * @param id string Identificador do controle de spotlight
+     */
+    getSpotlightControlFromList(id) {
+        return this.spotlightControlsList.contents.filter(val => val.spotlightId === id)[0];
+    }
+    /**
+     * Verifica se o controle de spotlight informado não foi registrado ainda
+     * @param spotlightControl SpotlightControl Controle do spotlight
+     * @returns boolean true se ainda não foi registrado na base, false caso contrário
+     */
+    isNewControl(spotlightControl) {
+        return !this.spotlightControlsList.contents.includes(spotlightControl);
+    }
+    /**
+     * Retorna um objeto de notificação referente ao botão clicado pelo usuário.
+     * @param userAction UserAction Ação realizada pelo usuário ao clicar nos botões da modal
+     * @returns SpotlightNotification Objeto de notificação
+     */
+    buildNotification(userAction) {
+        const spotlight = this.spotlightScreen.spotlight;
+        return {
+            clickedButton: userAction,
+            spotlightControlId: spotlight.id,
+            primaryButtonUrl: spotlight.primaryButtonUrl
+        };
+    }
+    close() {
+        this.visibleChange.emit(false);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SpotlightComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: SpotlightComponent, selector: "s-spotlight", inputs: { visible: "visible", menuId: "menuId", fade: "fade" }, outputs: { visibleChange: "visibleChange" }, ngImport: i0, template: "<div class=\"s-spotlight-overlay\" id=\"ol\" *ngIf=\"canAppear && visible\">\n    <div class=\"s-spotlight\" id=\"sl\" [ngClass]=\"{'s-effect-fadein': fade}\">\n        <div class=\"s-spotlight-header\">\n            <span class=\"s-spotlight-title\">{{header.toUpperCase()}}</span>\n            <a role=\"button\" class=\"s-spotlight-close\" (click)=\"close()\"><span class=\"fa fa-times\" aria-hidden=\"true\"></span></a>\n        </div>\n        <div class=\"s-img\">\n            <img src=\"{{imgUrl}}\">\n        </div>\n        <div class=\"s-spotlight-footer\">\n            <div class=\"s-spotlight-footer-left\">\n                <button\n                    pButton\n                    type=\"submit\"\n                    id=\"decline-button\"\n                    label=\"{{'platform.spotlight.no_interest' | translate}}\"\n                    (click)=\"onTertiary()\"\n                    class=\"ui-button-link\">\n                </button>\n            </div>\n            <div class=\"s-spotlight-footer-right\">\n                <button\n                pButton\n                type=\"submit\"\n                id=\"remember-button\"\n                label=\"{{'platform.spotlight.remember_late' | translate}}\"\n                (click)=\"onSecondary()\"\n                class=\"ui-button-raised ui-button-secondary\">\n            </button>\n            <button\n                pButton\n                label=\"{{primaryButtonLabel}}\"\n                type=\"submit\"\n                id=\"submit-button\"\n                (click)=\"onPrimary()\"\n                [pTooltip]=\"primaryButtonTooltip\"\n                tooltipPosition=\"top\"\n                showDelay=\"500\"\n                class=\"ui-button-raised\">\n            </button>\n        </div>\n    </div>\n</div>\n</div>", styles: [".s-spotlight-overlay{display:flex;position:fixed;z-index:10;left:0;top:0;width:100%;height:100%;overflow:auto;background-color:#000;background-color:#0006}.s-spotlight{border-radius:3px;background:#fff;margin:auto;overflow:hidden;animation:move .15s forwards}.s-spotlight-header,.s-spotlight-footer{display:flex;padding:15px}.s-spotlight-header{align-items:center;justify-content:space-between}.s-spotlight-footer,.s-spotlight-footer-right,.s-spotlight-footer-left{display:flex}.s-spotlight-footer-right{flex:2;justify-content:flex-end}.s-spotlight-footer-left{flex:1;justify-content:flex-start}.s-spotlight-title{font-family:Open Sans,sans-serif;font-size:16px;font-weight:400;color:#333}.s-spotlight-close{display:block;margin-left:15px;color:#000}.s-img{width:100%;display:flex;align-items:center;justify-content:center}.s-img img{width:100%}.s-effect-fadein{animation:fade .15s forwards}@keyframes fade{0%{opacity:0}to{opacity:1}}@media (max-width: 595px){.s-spotlight-footer,.s-spotlight-footer-right,.s-spotlight-footer-left{align-items:center;flex-direction:column-reverse}.s-spotlight-footer button{margin:0 0 15px!important;width:100%!important}}@media (min-width: 576px){.s-spotlight{width:100%}}@media (min-width: 768px){.s-spotlight{width:720px}.s-spotlight-footer,.s-spotlight-footer-right,.s-spotlight-footer-left{flex-direction:row}}@media (min-width: 992px){.s-spotlight{width:960px}}@media (min-width: 1200px){.s-spotlight{width:50%}}\n"], dependencies: [{ kind: "directive", type: i1.ButtonDirective, selector: "[pButton]", inputs: ["iconPos", "loadingIcon", "loading", "severity", "raised", "rounded", "text", "outlined", "size", "plain", "fluid", "label", "icon", "buttonProps"] }, { kind: "directive", type: i2.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "autoHide", "fitContent", "hideOnEscape", "pTooltip", "tooltipDisabled", "tooltipOptions"] }, { kind: "directive", type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i4.TranslatePipe, name: "translate" }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SpotlightComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 's-spotlight', template: "<div class=\"s-spotlight-overlay\" id=\"ol\" *ngIf=\"canAppear && visible\">\n    <div class=\"s-spotlight\" id=\"sl\" [ngClass]=\"{'s-effect-fadein': fade}\">\n        <div class=\"s-spotlight-header\">\n            <span class=\"s-spotlight-title\">{{header.toUpperCase()}}</span>\n            <a role=\"button\" class=\"s-spotlight-close\" (click)=\"close()\"><span class=\"fa fa-times\" aria-hidden=\"true\"></span></a>\n        </div>\n        <div class=\"s-img\">\n            <img src=\"{{imgUrl}}\">\n        </div>\n        <div class=\"s-spotlight-footer\">\n            <div class=\"s-spotlight-footer-left\">\n                <button\n                    pButton\n                    type=\"submit\"\n                    id=\"decline-button\"\n                    label=\"{{'platform.spotlight.no_interest' | translate}}\"\n                    (click)=\"onTertiary()\"\n                    class=\"ui-button-link\">\n                </button>\n            </div>\n            <div class=\"s-spotlight-footer-right\">\n                <button\n                pButton\n                type=\"submit\"\n                id=\"remember-button\"\n                label=\"{{'platform.spotlight.remember_late' | translate}}\"\n                (click)=\"onSecondary()\"\n                class=\"ui-button-raised ui-button-secondary\">\n            </button>\n            <button\n                pButton\n                label=\"{{primaryButtonLabel}}\"\n                type=\"submit\"\n                id=\"submit-button\"\n                (click)=\"onPrimary()\"\n                [pTooltip]=\"primaryButtonTooltip\"\n                tooltipPosition=\"top\"\n                showDelay=\"500\"\n                class=\"ui-button-raised\">\n            </button>\n        </div>\n    </div>\n</div>\n</div>", styles: [".s-spotlight-overlay{display:flex;position:fixed;z-index:10;left:0;top:0;width:100%;height:100%;overflow:auto;background-color:#000;background-color:#0006}.s-spotlight{border-radius:3px;background:#fff;margin:auto;overflow:hidden;animation:move .15s forwards}.s-spotlight-header,.s-spotlight-footer{display:flex;padding:15px}.s-spotlight-header{align-items:center;justify-content:space-between}.s-spotlight-footer,.s-spotlight-footer-right,.s-spotlight-footer-left{display:flex}.s-spotlight-footer-right{flex:2;justify-content:flex-end}.s-spotlight-footer-left{flex:1;justify-content:flex-start}.s-spotlight-title{font-family:Open Sans,sans-serif;font-size:16px;font-weight:400;color:#333}.s-spotlight-close{display:block;margin-left:15px;color:#000}.s-img{width:100%;display:flex;align-items:center;justify-content:center}.s-img img{width:100%}.s-effect-fadein{animation:fade .15s forwards}@keyframes fade{0%{opacity:0}to{opacity:1}}@media (max-width: 595px){.s-spotlight-footer,.s-spotlight-footer-right,.s-spotlight-footer-left{align-items:center;flex-direction:column-reverse}.s-spotlight-footer button{margin:0 0 15px!important;width:100%!important}}@media (min-width: 576px){.s-spotlight{width:100%}}@media (min-width: 768px){.s-spotlight{width:720px}.s-spotlight-footer,.s-spotlight-footer-right,.s-spotlight-footer-left{flex-direction:row}}@media (min-width: 992px){.s-spotlight{width:960px}}@media (min-width: 1200px){.s-spotlight{width:50%}}\n"] }]
+        }], propDecorators: { visible: [{
+                type: Input
+            }], menuId: [{
+                type: Input
+            }], fade: [{
+                type: Input
+            }], visibleChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spotlight.component.js","sourceRoot":"","sources":["../../../../../lib/src/modules/spotlight/component/spotlight.component.ts","../../../../../lib/src/modules/spotlight/component/spotlight.component.html"],"names":[],"mappings":"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","sourcesContent":["import { UserAction } from './../models/user-action.enum';\nimport { SpotlightNotification } from './../models/spotlight-notification.interface';\nimport { Component, EventEmitter, Input, OnInit, Output, inject } from '@angular/core';\nimport { SpotlightService } from '../service/spotlight.service';\nimport {\n  Spotlight,\n  SpotlightScreen,\n  EnumDisplayType,\n  EnumSpotlightStatus,\n  SpotlightControlList,\n  SpotlightUsersList,\n  SpotlightUser,\n  SpotlightControl\n} from '../models/index';\nimport { DatePipe } from '@angular/common';\nimport { CookieService } from 'ngx-cookie-service';\n\n@Component({\n  selector: 's-spotlight',\n  templateUrl: './spotlight.component.html',\n  styleUrls: ['./spotlight.component.scss']\n})\nexport class SpotlightComponent implements OnInit {\n  private readonly spotlightService = inject(SpotlightService);\n  private readonly cookieService = inject(CookieService);\n  private readonly datePipe = inject(DatePipe);\n\n\n  public header: string;\n  public imgUrl: string;\n  public primaryButtonLabel: string;\n  public primaryButtonTooltip: string;\n  public canAppear = false;\n\n  private currentUser: string;\n  private spotlightUsersList: SpotlightUsersList;\n  private spotlightControlsList: SpotlightControlList;\n  private spotlightScreen: SpotlightScreen;\n  private canEmitEvent: boolean;\n\n  @Input()\n  public visible = false;\n\n  @Input()\n  public menuId: string;\n\n  @Input()\n  public fade = false;\n\n  @Output()\n  public visibleChange = new EventEmitter<boolean>();\n\n  async ngOnInit() {\n    await this.setValues();\n    this.fetchSpotlight();\n  }\n\n  private async setValues() {\n    const userData: any = JSON.parse(this.cookieService.get('com.senior.token'));\n    this.currentUser = userData.username;\n    this.spotlightUsersList = await this.spotlightService.listSpotlightUsers();\n    this.spotlightControlsList = await this.spotlightService.listSpotlightControl();\n  }\n\n  private setValuesInSpotlight(values: Spotlight): void {\n    this.header = values.spotlightTitle;\n    this.imgUrl = values.bannerUrl;\n    this.primaryButtonLabel = values.primaryButtonLabel;\n    this.primaryButtonTooltip = values.primaryButtonHint;\n  }\n\n  private getShowDate(days: number): string {\n    const currentDate = new Date();\n    return this.datePipe.transform(currentDate.setDate(currentDate.getDate() + days).toString(), 'yyyy-MM-dd');\n  }\n\n  private fetchSpotlight(): void {\n    this.spotlightService.listSpotlightScreen().subscribe(value => {\n      this.spotlightScreen = value.contents.filter(val => val.screenMenuId === this.menuId)[0];\n      if (this.spotlightScreen) {\n        this.showSpotlight(this.spotlightScreen.spotlight);\n      }\n    });\n  }\n\n  private showSpotlight(spotlight: Spotlight): void {\n    if (this.validateDate(spotlight.initialDate) && this.validateFinalDate(spotlight.finalDate) && this.validateSpotlight(spotlight)) {\n      this.setValuesInSpotlight(spotlight);\n      this.canAppear = true;\n      const control = this.getSpotlightControlFromList(this.spotlightScreen.spotlight.id);\n      this.canEmitEvent = !control || this.currentUser !== control.firstUser;\n    }\n  }\n\n  private validateDate(date: string): boolean {\n    if (date) {\n      const currentDate = this.datePipe.transform(new Date().toString(), 'yyyy-MM-dd');\n      const initialDate = this.datePipe.transform(date, 'yyyy-MM-dd');\n\n      return currentDate >= initialDate;\n    }\n    return false;\n  }\n\n  private validateFinalDate(date: string): boolean {\n    if (date) {\n      const currentDate = this.datePipe.transform(new Date().toString(), 'yyyy-MM-dd');\n      const finalDate = this.datePipe.transform(date, 'yyyy-MM-dd');\n\n      return currentDate <= finalDate;\n    }\n    return true;\n  }\n\n  private validateSpotlight(spotlight: Spotlight): boolean {\n    if (!this.validateControlsList(this.spotlightControlsList, spotlight, this.currentUser)) {\n      return false;\n    }\n    if (!this.validateDisplayType(spotlight, this.spotlightUsersList, this.spotlightControlsList, this.currentUser)) {\n      return false;\n    }\n    return true;\n  }\n\n  private validateControlsList(controlsList: SpotlightControlList, spotlight: Spotlight, currentUser: string): boolean {\n    if (controlsList.totalElements) {\n\n      const notCompatibleControls = controlsList.contents.filter(control => {\n        if (control.status === EnumSpotlightStatus.ACTIVE) {\n          return control.spotlightId === spotlight.id;\n\n        } else if (control.status === EnumSpotlightStatus.IN_PROGRESS) {\n            return control.spotlightId === spotlight.id && control.firstUser !== currentUser;\n        }\n      });\n\n      if (notCompatibleControls.length > 0) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  private validateDisplayType(\n    spotlight: Spotlight,\n    usersList: SpotlightUsersList,\n    controlsList: SpotlightControlList,\n    currentUser: string\n  ): boolean {\n\n    switch (spotlight.displayType) {\n      case EnumDisplayType.ADVERSITING:\n        return usersList.totalElements ? this.validateUser(usersList.contents, spotlight) : true;\n\n      case EnumDisplayType.INTEGRATION:\n\n        if (controlsList.totalElements) {\n          const compatibleControls = controlsList.contents.filter(control => {\n\n              switch (control.status) {\n\n                case EnumSpotlightStatus.NO_STARTED:\n                  return control.spotlightId === spotlight.id;\n\n                case EnumSpotlightStatus.REFUSED:\n                  return usersList.totalElements ? this.validateUser(usersList.contents, spotlight) : true;\n\n                case EnumSpotlightStatus.IN_PROGRESS:\n                  return control.firstUser === currentUser\n                    && control.spotlightId === spotlight.id;\n              }\n          });\n          if (compatibleControls.length === 0) {\n            return false;\n          }\n        }\n        return true;\n    }\n  }\n\n  private validateUser(users: SpotlightUser[], spotlight: Spotlight): boolean {\n    let spotlightUsers = users.filter(user => user.spotlightId === spotlight.id);\n\n    if (!spotlightUsers.length) {\n      spotlightUsers = users.filter(user => user.userOperation === this.currentUser);\n\n      return spotlightUsers.length === 0;\n    }\n\n    const compatibleUserToValidate = spotlightUsers.filter(user => user.userOperation === this.currentUser)[0];\n\n    return compatibleUserToValidate ? this.validateDate(compatibleUserToValidate.showDate) : true;\n  }\n\n  private saveSpotlightUser(days?: number): void {\n\n    const spotlight = this.spotlightScreen.spotlight;\n\n    const user = this.spotlightUsersList.contents.filter(val => {\n      return val.spotlightId === spotlight.id\n        && val.userOperation === this.currentUser;\n    })[0];\n\n    let spotlightUser: SpotlightUser = {\n      spotlightId: spotlight.id,\n      showDate: days ? this.getShowDate(days) : null,\n      userOperation: this.currentUser\n    };\n\n    if (user) {\n      spotlightUser = {\n        id: user.id,\n        ...spotlightUser\n      };\n    }\n    this.spotlightService.saveSpotlightUser(spotlightUser).subscribe();\n  }\n\n  public onPrimary() {\n    const spotlight = this.spotlightScreen.spotlight;\n    const notification = this.buildNotification(UserAction.CONFIRMED);\n\n    this.saveSpotlightControl();\n    this.saveSpotlightUser();\n\n    if (this.canEmitEvent) {\n      this.spotlightService.notificateSpotlight(notification).subscribe();\n    }\n\n    if (spotlight.primaryButtonUrl) {\n      window.open(spotlight.primaryButtonUrl);\n    }\n\n    this.close();\n  }\n\n  public onSecondary(): void {\n    const notification = this.buildNotification(UserAction.POSTPONED);\n\n    this.saveSpotlightControl(EnumSpotlightStatus.REFUSED);\n    this.saveSpotlightUser(this.spotlightScreen.spotlight.daysRememberLate);\n    this.spotlightService.notificateSpotlight(notification).subscribe();\n\n    this.close();\n  }\n\n  public onTertiary(): void {\n    const notification = this.buildNotification(UserAction.REFUSED);\n\n    this.saveSpotlightControl(EnumSpotlightStatus.REFUSED);\n    this.saveSpotlightUser(this.spotlightScreen.spotlight.daysNotInterested);\n    this.spotlightService.notificateSpotlight(notification).subscribe();\n\n    this.close();\n  }\n\n  /**\n   * Verifica se um registro de usuário pertence ao usuário logado e corresponde ao spotlight atual\n   * @param user SpotlightUser Objeto representando o registro do usuário para uma spotlight\n   * @param spotlight Spotlight Spotlight\n   * @returns boolean true se corresponder ao spotlight atual, false caso contrário\n   */\n  private hasThisRegister(user: SpotlightUser, spotlight: Spotlight): boolean {\n    return (user.spotlightId === spotlight.id && user.userOperation === this.currentUser);\n  }\n\n  /**\n   * Verifica se um registro de usuário pertece ao usuário logado, mas não corresponde ao spotlight atual\n   * @param user SpotlightUser Objeto representando o registro do usuário para uma spotlight\n   * @param spotlight Spotlight Spotlight\n   * @returns boolean true se corresponder ao spotlight atual, false caso contrário\n   */\n  private hasAnotherRegister(user: SpotlightUser, spotlight: Spotlight): boolean {\n    return user.spotlightId !== spotlight.id && user.userOperation === this.currentUser;\n  }\n\n  /**\n   * Persiste um novo registro de controle para o spotlight atual se\n   * não for encontrado nenhum na lista de controles carregada inicialmente\n   * @param status EnumSpotlightStatus Status do controle do spotlight. Se nenhum for informado, IN_PROGRESS será aplicado\n   * @returns SpotlightControl Controle do spotlight recuperado/pesistido\n   */\n  private saveSpotlightControl(status = EnumSpotlightStatus.IN_PROGRESS): SpotlightControl {\n    const spotlight = this.spotlightScreen.spotlight;\n    let control: SpotlightControl = this.getSpotlightControlFromList(spotlight.id);\n\n    if (!control) {\n      control = {\n        spotlightId: spotlight.id,\n        status: status,\n        firstUser: this.currentUser\n      };\n    }\n\n    if (this.isNewControl(control) || control.status !== EnumSpotlightStatus.IN_PROGRESS) {\n      control.status = status;\n      control.firstUser = status === EnumSpotlightStatus.IN_PROGRESS ? this.currentUser : '';\n      this.spotlightService.saveSpotlightControl(control).subscribe();\n    }\n\n    return control;\n  }\n\n  /**\n   * Retorna o controle de spotlight correspondente ao identificador\n   * informado na lista de controles carregada na inicialização do componente\n   * @param id string Identificador do controle de spotlight\n   */\n  private getSpotlightControlFromList(id: string): SpotlightControl {\n    return this.spotlightControlsList.contents.filter(val =>  val.spotlightId === id)[0];\n  }\n\n  /**\n   * Verifica se o controle de spotlight informado não foi registrado ainda\n   * @param spotlightControl SpotlightControl Controle do spotlight\n   * @returns boolean true se ainda não foi registrado na base, false caso contrário\n   */\n  private isNewControl(spotlightControl: SpotlightControl): boolean {\n    return !this.spotlightControlsList.contents.includes(spotlightControl);\n  }\n\n  /**\n   * Retorna um objeto de notificação referente ao botão clicado pelo usuário.\n   * @param userAction UserAction Ação realizada pelo usuário ao clicar nos botões da modal\n   * @returns SpotlightNotification Objeto de notificação\n   */\n  private buildNotification(userAction: UserAction): SpotlightNotification {\n    const spotlight = this.spotlightScreen.spotlight;\n\n    return {\n      clickedButton: userAction,\n      spotlightControlId: spotlight.id,\n      primaryButtonUrl: spotlight.primaryButtonUrl\n    };\n  }\n\n  public close(): void {\n    this.visibleChange.emit(false);\n  }\n}\n","<div class=\"s-spotlight-overlay\" id=\"ol\" *ngIf=\"canAppear && visible\">\n    <div class=\"s-spotlight\" id=\"sl\" [ngClass]=\"{'s-effect-fadein': fade}\">\n        <div class=\"s-spotlight-header\">\n            <span class=\"s-spotlight-title\">{{header.toUpperCase()}}</span>\n            <a role=\"button\" class=\"s-spotlight-close\" (click)=\"close()\"><span class=\"fa fa-times\" aria-hidden=\"true\"></span></a>\n        </div>\n        <div class=\"s-img\">\n            <img src=\"{{imgUrl}}\">\n        </div>\n        <div class=\"s-spotlight-footer\">\n            <div class=\"s-spotlight-footer-left\">\n                <button\n                    pButton\n                    type=\"submit\"\n                    id=\"decline-button\"\n                    label=\"{{'platform.spotlight.no_interest' | translate}}\"\n                    (click)=\"onTertiary()\"\n                    class=\"ui-button-link\">\n                </button>\n            </div>\n            <div class=\"s-spotlight-footer-right\">\n                <button\n                pButton\n                type=\"submit\"\n                id=\"remember-button\"\n                label=\"{{'platform.spotlight.remember_late' | translate}}\"\n                (click)=\"onSecondary()\"\n                class=\"ui-button-raised ui-button-secondary\">\n            </button>\n            <button\n                pButton\n                label=\"{{primaryButtonLabel}}\"\n                type=\"submit\"\n                id=\"submit-button\"\n                (click)=\"onPrimary()\"\n                [pTooltip]=\"primaryButtonTooltip\"\n                tooltipPosition=\"top\"\n                showDelay=\"500\"\n                class=\"ui-button-raised\">\n            </button>\n        </div>\n    </div>\n</div>\n</div>"]}

package/esm2022/modules/spotlight/index.mjs

@@ -0,0 +1,3 @@
+export * from './spotlight.module';
+export * from './component/spotlight.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWIvc3JjL21vZHVsZXMvc3BvdGxpZ2h0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxpQ0FBaUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc3BvdGxpZ2h0Lm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBvbmVudC9zcG90bGlnaHQuY29tcG9uZW50JztcbiJdfQ==

package/esm2022/modules/spotlight/locale/fallback.mjs

@@ -0,0 +1,5 @@
+export const fallback = {
+    'platform.spotlight.no_interest': 'Não tenho interesse',
+    'platform.spotlight.remember_late': 'Lembrar mais tarde'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFsbGJhY2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWIvc3JjL21vZHVsZXMvc3BvdGxpZ2h0L2xvY2FsZS9mYWxsYmFjay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxRQUFRLEdBQVE7SUFFekIsZ0NBQWdDLEVBQUcscUJBQXFCO0lBQ3hELGtDQUFrQyxFQUFHLG9CQUFvQjtDQUM1RCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IGZhbGxiYWNrOiBhbnkgPSB7XG5cbiAgICAncGxhdGZvcm0uc3BvdGxpZ2h0Lm5vX2ludGVyZXN0JyA6ICdOw6NvIHRlbmhvIGludGVyZXNzZScsXG4gICAgJ3BsYXRmb3JtLnNwb3RsaWdodC5yZW1lbWJlcl9sYXRlJyA6ICdMZW1icmFyIG1haXMgdGFyZGUnXG59O1xuIl19

package/esm2022/modules/spotlight/models/display-type.enum.mjs

@@ -0,0 +1,6 @@
+export var EnumDisplayType;
+(function (EnumDisplayType) {
+    EnumDisplayType["ADVERSITING"] = "ADVERSITING";
+    EnumDisplayType["INTEGRATION"] = "INTEGRATION";
+})(EnumDisplayType || (EnumDisplayType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzcGxheS10eXBlLmVudW0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWIvc3JjL21vZHVsZXMvc3BvdGxpZ2h0L21vZGVscy9kaXNwbGF5LXR5cGUuZW51bS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSxlQUdYO0FBSEQsV0FBWSxlQUFlO0lBQ3ZCLDhDQUEyQixDQUFBO0lBQzNCLDhDQUEyQixDQUFBO0FBQy9CLENBQUMsRUFIVyxlQUFlLEtBQWYsZUFBZSxRQUcxQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIEVudW1EaXNwbGF5VHlwZSB7XG4gICAgQURWRVJTSVRJTkcgPSAnQURWRVJTSVRJTkcnLFxuICAgIElOVEVHUkFUSU9OID0gJ0lOVEVHUkFUSU9OJ1xufVxuIl19