@rededor/site-front-end-lib 0.0.72 → 0.0.74

package/esm2022/lib/services/cura/cura.service.mjs

@@ -0,0 +1,111 @@
+import { DOCUMENT, isPlatformServer } from '@angular/common';
+import { Inject, Injectable, Optional, PLATFORM_ID } from '@angular/core';
+import { fromEvent, startWith } from 'rxjs';
+import { IconCuraDefaultType } from '../../enums/IconCuraDefaultType.enum';
+import { SSR_CURA_API } from '../../tokens/CuraApi';
+import { LIB_CONFIG } from '../../tokens/LibConfig';
+import * as i0 from "@angular/core";
+import * as i1 from "../log/log.service";
+export class CuraService {
+    constructor(log, platformId, document, libConfig, ssrCuraAPI) {
+        this.log = log;
+        this.platformId = platformId;
+        this.document = document;
+        this.libConfig = libConfig;
+        this.ssrCuraAPI = ssrCuraAPI;
+        this.curaAPISubscription = null;
+        this.curaApi = null;
+        this.curaInit();
+    }
+    curaInit() {
+        if (!this.curaAPISubscription) {
+            this.curaAPISubscriptionInit();
+        }
+    }
+    curaAPISubscriptionInit() {
+        if (this.document.defaultView) {
+            if (isPlatformServer(this.platformId)) {
+                this.injectCuraAPI();
+            }
+            this.curaAPISubscription = fromEvent(this.document.defaultView, 'CuraAPIReady')
+                .pipe(startWith({
+                detail: { api: this.document.defaultView?.CuraAPI },
+            }))
+                .subscribe({
+                next: (event) => {
+                    this.curaApi = event?.detail?.api;
+                },
+                error: (error) => {
+                    this.log.logMsg(JSON.stringify(error), 'ERROR');
+                },
+            });
+        }
+    }
+    injectCuraAPI() {
+        if (this.document.defaultView && !this.document.defaultView['CuraAPI']) {
+            Object.defineProperty(this.document.defaultView, 'CuraAPI', {
+                value: this.ssrCuraAPI,
+            });
+        }
+    }
+    loadTheme(theme) {
+        this.curaApi?.theme?.load(theme);
+    }
+    getColor(colorWithDepth, opacity = 1) {
+        return this.curaApi?.theme?.colors.getColor(colorWithDepth, opacity) ?? null;
+    }
+    getSpacing() {
+        return this.curaApi?.theme.spacing.getSpacing() ?? null;
+    }
+    getFontFamily(type) {
+        return this.curaApi?.theme.fonts.getFamily(type) ?? null;
+    }
+    getFontWeights() {
+        return this.curaApi?.theme.fonts.getWeights() ?? {};
+    }
+    getFontSize() {
+        return this.curaApi?.theme.fonts.getSize() ?? '';
+    }
+    getFontColor() {
+        return this.curaApi?.theme.fonts.getColor() ?? '';
+    }
+    getCuraIconName(icon) {
+        if (IconCuraDefaultType[icon]) {
+            return IconCuraDefaultType[icon];
+        }
+        else {
+            return this.getCuraSystemIconName(icon);
+        }
+    }
+    getCuraSystemIconName(icon) {
+        if (this.libConfig.iconsetDefaultList?.includes(icon))
+            return icon;
+        return '';
+    }
+    ngOnDestroy() {
+        this.curaAPISubscription?.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CuraService, deps: [{ token: i1.LogService }, { token: PLATFORM_ID }, { token: DOCUMENT }, { token: LIB_CONFIG }, { token: SSR_CURA_API, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CuraService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CuraService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.LogService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LIB_CONFIG]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [SSR_CURA_API]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cura.service.js","sourceRoot":"","sources":["../../../../../../projects/site-front-end-lib/src/lib/services/cura/cura.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT, isPlatformServer } from '@angular/common';\r\nimport { Inject, Injectable, OnDestroy, Optional, PLATFORM_ID } from '@angular/core';\r\nimport CuraAPI from '@rededor/cura/dist/types/api/cura-api';\r\nimport { Subscription, fromEvent, startWith } from 'rxjs';\r\nimport { LogService } from '../log/log.service';\r\nimport { IconCuraDefaultType } from '../../enums/IconCuraDefaultType.enum';\r\nimport { SSR_CURA_API } from '../../tokens/CuraApi';\r\nimport { LIB_CONFIG, LibConfig } from '../../tokens/LibConfig';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class CuraService implements OnDestroy {\r\n  private curaAPISubscription: Subscription | null = null;\r\n  private curaApi: CuraAPI | null = null;\r\n\r\n  constructor(\r\n    private log: LogService,\r\n    @Inject(PLATFORM_ID) private platformId: object,\r\n    @Inject(DOCUMENT) private document: Document,\r\n    @Inject(LIB_CONFIG) private libConfig: LibConfig,\r\n    @Optional() @Inject(SSR_CURA_API) private ssrCuraAPI: any,\r\n  ) {\r\n    this.curaInit();\r\n  }\r\n\r\n  curaInit() {\r\n    if (!this.curaAPISubscription) {\r\n      this.curaAPISubscriptionInit();\r\n    }\r\n  }\r\n\r\n  private curaAPISubscriptionInit() {\r\n    if (this.document.defaultView) {\r\n      if (isPlatformServer(this.platformId)) {\r\n        this.injectCuraAPI();\r\n      }\r\n      this.curaAPISubscription = fromEvent(this.document.defaultView, 'CuraAPIReady')\r\n        .pipe(\r\n          startWith({\r\n            detail: { api: (this.document.defaultView as any)?.CuraAPI },\r\n          }),\r\n        )\r\n        .subscribe({\r\n          next: (event) => {\r\n            this.curaApi = (event as CustomEvent)?.detail?.api as CuraAPI;\r\n          },\r\n          error: (error) => {\r\n            this.log.logMsg(JSON.stringify(error), 'ERROR');\r\n          },\r\n        });\r\n    }\r\n  }\r\n\r\n  private injectCuraAPI() {\r\n    if (this.document.defaultView && !(this.document.defaultView as any)['CuraAPI']) {\r\n      Object.defineProperty(this.document.defaultView, 'CuraAPI', {\r\n        value: this.ssrCuraAPI,\r\n      });\r\n    }\r\n  }\r\n\r\n  loadTheme(theme: string) {\r\n    this.curaApi?.theme?.load(theme);\r\n  }\r\n\r\n  getColor(colorWithDepth: string, opacity: number = 1): string | null {\r\n    return this.curaApi?.theme?.colors.getColor(colorWithDepth, opacity) ?? null;\r\n  }\r\n\r\n  getSpacing(): string | null {\r\n    return this.curaApi?.theme.spacing.getSpacing() ?? null;\r\n  }\r\n\r\n  getFontFamily(type: string): string | null {\r\n    return this.curaApi?.theme.fonts.getFamily(type) ?? null;\r\n  }\r\n\r\n  getFontWeights(): { [alias: string]: string } {\r\n    return this.curaApi?.theme.fonts.getWeights() ?? {};\r\n  }\r\n\r\n  getFontSize(): string {\r\n    return this.curaApi?.theme.fonts.getSize() ?? '';\r\n  }\r\n\r\n  getFontColor(): string {\r\n    return this.curaApi?.theme.fonts.getColor() ?? '';\r\n  }\r\n\r\n  getCuraIconName(icon: string): string {\r\n    if (IconCuraDefaultType[icon as keyof typeof IconCuraDefaultType]) {\r\n      return IconCuraDefaultType[icon as keyof typeof IconCuraDefaultType];\r\n    } else {\r\n      return this.getCuraSystemIconName(icon);\r\n    }\r\n  }\r\n\r\n  private getCuraSystemIconName(icon: string): string {\r\n    if (this.libConfig.iconsetDefaultList?.includes(icon)) return icon;\r\n    return '';\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.curaAPISubscription?.unsubscribe();\r\n  }\r\n}\r\n"]}

package/esm2022/lib/services/http-client/http-client.service.mjs

@@ -0,0 +1,55 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Inject, Injectable, PLATFORM_ID } from '@angular/core';
+import { LIB_CONFIG } from '../../tokens/LibConfig';
+import { isPlatformServer } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "ngx-device-detector";
+/* Adiciona os Headers necessários para funcionamento do site back-end */
+export class HttpClientService {
+    constructor(platformId, libConfig, http, deviceService) {
+        this.platformId = platformId;
+        this.libConfig = libConfig;
+        this.http = http;
+        this.deviceService = deviceService;
+    }
+    get(url) {
+        const headers = this.getHeaders();
+        return this.http.get(url, { headers });
+    }
+    post(url, data) {
+        const headers = this.getHeaders();
+        return this.http.post(url, data, { headers });
+    }
+    getHeaders() {
+        const baseHeaders = new HttpHeaders()
+            .set("x-origin-application", this.libConfig.xOriginApplication)
+            .set("x-origin-channel", this.getOriginChannel())
+            .set("x-origin-device", this.getOriginDevice());
+        if (isPlatformServer(this.platformId) && this.libConfig.server) {
+            return baseHeaders.append("authorization", "Basic " + Buffer.from(`${this.libConfig.siteApi.auth.user}:${this.libConfig.siteApi.auth.password}`).toString('base64'));
+        }
+        else {
+            return baseHeaders.append("client_id", this.libConfig.client_id);
+        }
+    }
+    getOriginChannel() {
+        return this.deviceService.isDesktop() ? 'desktop' : 'mobile';
+    }
+    getOriginDevice() {
+        return `app-${this.deviceService.getDeviceInfo().os}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HttpClientService, deps: [{ token: PLATFORM_ID }, { token: LIB_CONFIG }, { token: i1.HttpClient }, { token: i2.DeviceDetectorService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HttpClientService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HttpClientService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LIB_CONFIG]
+                }] }, { type: i1.HttpClient }, { type: i2.DeviceDetectorService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/index.mjs

@@ -0,0 +1,17 @@
+export * from './algolia/algolia.service';
+export * from './cura/cura.service';
+export * from './http-client/http-client.service';
+export * from './log/log.service';
+export * from './modal/modal.service';
+export * from './modal-drawer/modal-drawer.service';
+export * from './ngu-carousel/ngu-carousel.service';
+export * from './phone/phone.service';
+export * from './privacy-tools/privacy-tools.service';
+export * from './site-back-end/site-back-end.service';
+export * from './seo/seo.service';
+export * from './server-response/server-response.service';
+export * from './ssr-loading/ssr-loading.service';
+export * from './transfer-state/transfer-state.service';
+export * from '../components/header/services/header.service';
+export * from './algolia-search-api/algolia-search-api.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zaXRlLWZyb250LWVuZC1saWIvc3JjL2xpYi9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLHVDQUF1QyxDQUFDO0FBQ3RELGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYywyQ0FBMkMsQ0FBQztBQUMxRCxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyw4Q0FBOEMsQ0FBQztBQUM3RCxjQUFjLGlEQUFpRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hbGdvbGlhL2FsZ29saWEuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vY3VyYS9jdXJhLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2h0dHAtY2xpZW50L2h0dHAtY2xpZW50LnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xvZy9sb2cuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbW9kYWwvbW9kYWwuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbW9kYWwtZHJhd2VyL21vZGFsLWRyYXdlci5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9uZ3UtY2Fyb3VzZWwvbmd1LWNhcm91c2VsLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL3Bob25lL3Bob25lLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL3ByaXZhY3ktdG9vbHMvcHJpdmFjeS10b29scy5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9zaXRlLWJhY2stZW5kL3NpdGUtYmFjay1lbmQuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc2VvL3Nlby5zZXJ2aWNlJztcclxuZXhwb3J0ICogZnJvbSAnLi9zZXJ2ZXItcmVzcG9uc2Uvc2VydmVyLXJlc3BvbnNlLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL3Nzci1sb2FkaW5nL3Nzci1sb2FkaW5nLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL3RyYW5zZmVyLXN0YXRlL3RyYW5zZmVyLXN0YXRlLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuLi9jb21wb25lbnRzL2hlYWRlci9zZXJ2aWNlcy9oZWFkZXIuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vYWxnb2xpYS1zZWFyY2gtYXBpL2FsZ29saWEtc2VhcmNoLWFwaS5zZXJ2aWNlJztcclxuIl19

package/esm2022/lib/services/log/log.service.mjs

@@ -0,0 +1,46 @@
+import { Injectable, Inject, PLATFORM_ID } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { LIB_CONFIG } from '../../tokens/LibConfig';
+import { getSiteUrl } from '../../helpers';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class LogService {
+    constructor(libConfig, platformId, location) {
+        this.libConfig = libConfig;
+        this.platformId = platformId;
+        this.location = location;
+    }
+    logMsg(msg, label) {
+        label = label ? `${label} ` : '';
+        if (!isPlatformBrowser(this.platformId) || (isPlatformBrowser(this.platformId) && !this.libConfig?.production)) {
+            console.log(`${label}${msg}`);
+        }
+    }
+    logLoad(component) {
+        this.logMsg(`${this.getPageURL()}${component ? ' - ' + component : ''}`, 'LOAD');
+    }
+    log404(component) {
+        this.logMsg(`${this.getPageURL()}${component ? ' - ' + component : ''}`, '404');
+    }
+    log500(component) {
+        this.logMsg(`${this.getPageURL()}${component ? ' - ' + component : ''}`, '500');
+    }
+    getPageURL() {
+        return `${getSiteUrl(this.libConfig?.siteUrl, this.libConfig?.siteSufix)}${this.location.path()}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LogService, deps: [{ token: LIB_CONFIG }, { token: PLATFORM_ID }, { token: i1.Location }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LIB_CONFIG]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i1.Location }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/modal/modal.service.mjs

@@ -0,0 +1,56 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AbstractModalComponent {
+}
+export class ModalService {
+    constructor() {
+        this.reference = null;
+    }
+    open() {
+        this.reference?.open();
+    }
+    setReference(element) {
+        this.reference = element;
+    }
+    setHeader(header) {
+        if (!this.reference)
+            return;
+        this.reference.modalHeader = header;
+    }
+    setTitle(title) {
+        if (!this.reference)
+            return;
+        this.reference.modalTitle = title;
+    }
+    setContent(content, context = {}) {
+        if (!this.reference)
+            return;
+        this.reference.modalContent = content;
+        this.reference.modalContentContext = context;
+    }
+    setActions(actions) {
+        if (!this.reference)
+            return;
+        this.reference.modalActions = actions;
+    }
+    setStyle(style) {
+        if (!this.reference)
+            return;
+        this.reference.componentStyle = style;
+    }
+    setDefaultPhoneModal(modal) {
+        this.defaultPhoneModal = modal;
+    }
+    close() {
+        this.reference?.close();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModalService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModalService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModalService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/modal-drawer/modal-drawer.service.mjs

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AbstractModalDrawerComponent {
+}
+export class ModalDrawerService {
+    constructor() {
+        this.reference = null;
+    }
+    open() {
+        this.reference?.openSheet();
+    }
+    setReference(element) {
+        this.reference = element;
+    }
+    setContent(content) {
+        if (!this.reference)
+            return;
+        this.reference.modalContent = content;
+    }
+    setStyle(style) {
+        if (!this.reference)
+            return;
+        this.reference.componentStyle = style;
+    }
+    setHeight(value) {
+        if (!this.reference)
+            return;
+        this.reference.maxHeight = value;
+    }
+    close() {
+        this.reference?.closeSheet();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModalDrawerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModalDrawerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModalDrawerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/ngu-carousel/ngu-carousel.service.mjs

@@ -0,0 +1,81 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NguCarouselService {
+    constructor() {
+        this._defaultCarouselConfig = {
+            grid: { xs: 1.2, sm: 1.2, md: 3.2, lg: 4.2, xl: 5.2, all: 0 },
+            gridBreakpoints: { sm: 360, md: 768, lg: 1366, xl: 1920 },
+            slide: 1,
+            speed: 500,
+            interval: {
+                timing: 7000,
+                initialDelay: 1000,
+            },
+            point: {
+                visible: false,
+            },
+            velocity: 0.5,
+            load: 1,
+            loop: true,
+            touch: true,
+            easing: 'ease-in-out',
+        };
+    }
+    get defaultCarouselConfig() {
+        return { ...JSON.parse(JSON.stringify(this._defaultCarouselConfig)) };
+    }
+    customCarouselConfig(config) {
+        return {
+            ...this.defaultCarouselConfig,
+            ...config,
+        };
+    }
+    moveTo(carousel, index) {
+        carousel.moveTo(index);
+    }
+    scrollLeft(carousel, loop = true) {
+        if (carousel.isFirst || carousel.activePoint < 1) {
+            if (loop) {
+                carousel.moveTo(carousel.pointNumbers[carousel.pointNumbers.length - 1]);
+            }
+        }
+        else {
+            carousel.moveTo(carousel.activePoint - 1);
+        }
+    }
+    scrollRight(carousel, loop = true) {
+        if (carousel.isLast || carousel.activePoint > carousel.pointNumbers.length - 1) {
+            if (loop) {
+                carousel.moveTo(0);
+            }
+        }
+        else {
+            carousel.moveTo(carousel.activePoint + 1);
+        }
+    }
+    needShowControls(config, width, itemsLength = 0) {
+        const { grid: { xs, sm, md, lg, xl }, gridBreakpoints, } = config;
+        if (width > (gridBreakpoints?.xl ?? 0)) {
+            return itemsLength > (xl ?? 0);
+        }
+        if (width > (gridBreakpoints?.lg ?? 0)) {
+            return itemsLength > lg;
+        }
+        if (width > (gridBreakpoints?.md ?? 0)) {
+            return itemsLength > md;
+        }
+        if (width > (gridBreakpoints?.sm ?? 0)) {
+            return itemsLength > sm;
+        }
+        return itemsLength > xs;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NguCarouselService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NguCarouselService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NguCarouselService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/phone/phone.service.mjs

@@ -0,0 +1,28 @@
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class PhoneService {
+    constructor(document) {
+        this.document = document;
+        this.telRegex = /tel:/;
+        this.phoneModalIsAllowed = true; // variavel utilizada para permitir/bloquear o modal de telefone
+    }
+    /** Verifica se o 'href' é de telefone e se a janela está em tamanho desktop */
+    isPhoneModal(href) {
+        const width = this.document.defaultView?.innerWidth ?? 0;
+        const SMALL_BREAKPOINT = 718;
+        return this.telRegex.test(href) && width > SMALL_BREAKPOINT;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PhoneService, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PhoneService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PhoneService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGhvbmUuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3NpdGUtZnJvbnQtZW5kLWxpYi9zcmMvbGliL3NlcnZpY2VzL3Bob25lL3Bob25lLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQzNDLE9BQU8sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUtuRCxNQUFNLE9BQU8sWUFBWTtJQUt2QixZQUFzQyxRQUFrQjtRQUFsQixhQUFRLEdBQVIsUUFBUSxDQUFVO1FBSmhELGFBQVEsR0FBRyxNQUFNLENBQUM7UUFFbkIsd0JBQW1CLEdBQVksSUFBSSxDQUFDLENBQUMsZ0VBQWdFO0lBRWpELENBQUM7SUFFNUQsK0VBQStFO0lBQ3hFLFlBQVksQ0FBQyxJQUFZO1FBQzlCLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsV0FBVyxFQUFFLFVBQVUsSUFBSSxDQUFDLENBQUM7UUFDekQsTUFBTSxnQkFBZ0IsR0FBRyxHQUFHLENBQUM7UUFDN0IsT0FBTyxJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxLQUFLLEdBQUcsZ0JBQWdCLENBQUM7SUFDOUQsQ0FBQzsrR0FaVSxZQUFZLGtCQUtILFFBQVE7bUhBTGpCLFlBQVksY0FGWCxNQUFNOzs0RkFFUCxZQUFZO2tCQUh4QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQjs7MEJBTWMsTUFBTTsyQkFBQyxRQUFRIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRE9DVU1FTlQgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xyXG5pbXBvcnQgeyBJbmplY3QsIEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbkBJbmplY3RhYmxlKHtcclxuICBwcm92aWRlZEluOiAncm9vdCcsXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBQaG9uZVNlcnZpY2Uge1xyXG4gIHByaXZhdGUgdGVsUmVnZXggPSAvdGVsOi87XHJcblxyXG4gIHB1YmxpYyBwaG9uZU1vZGFsSXNBbGxvd2VkOiBib29sZWFuID0gdHJ1ZTsgLy8gdmFyaWF2ZWwgdXRpbGl6YWRhIHBhcmEgcGVybWl0aXIvYmxvcXVlYXIgbyBtb2RhbCBkZSB0ZWxlZm9uZVxyXG5cclxuICBjb25zdHJ1Y3RvcihASW5qZWN0KERPQ1VNRU5UKSBwcml2YXRlIGRvY3VtZW50OiBEb2N1bWVudCkge31cclxuXHJcbiAgLyoqIFZlcmlmaWNhIHNlIG8gJ2hyZWYnIMOpIGRlIHRlbGVmb25lIGUgc2UgYSBqYW5lbGEgZXN0w6EgZW0gdGFtYW5obyBkZXNrdG9wICovXHJcbiAgcHVibGljIGlzUGhvbmVNb2RhbChocmVmOiBzdHJpbmcpIHtcclxuICAgIGNvbnN0IHdpZHRoID0gdGhpcy5kb2N1bWVudC5kZWZhdWx0Vmlldz8uaW5uZXJXaWR0aCA/PyAwO1xyXG4gICAgY29uc3QgU01BTExfQlJFQUtQT0lOVCA9IDcxODtcclxuICAgIHJldHVybiB0aGlzLnRlbFJlZ2V4LnRlc3QoaHJlZikgJiYgd2lkdGggPiBTTUFMTF9CUkVBS1BPSU5UO1xyXG4gIH1cclxufVxyXG4iXX0=

package/esm2022/lib/services/privacy-tools/privacy-tools.service.mjs

@@ -0,0 +1,92 @@
+import { DOCUMENT, isPlatformBrowser, isPlatformServer } from '@angular/common';
+import { Inject, Injectable, PLATFORM_ID } from '@angular/core';
+import * as i0 from "@angular/core";
+export class PrivacyToolsService {
+    constructor(document, platformId) {
+        this.document = document;
+        this.platformId = platformId;
+        this.cookieBannerScriptId = 'PrivacyToolsScript';
+        this.cookieBannerStyleId = 'PrivacyToolsStyle';
+        this.cookieBannerScriptElement = null;
+        this.configOptions = {};
+        this.cookieConsent = null;
+    }
+    /* Config */
+    config(options) {
+        this.configOptions = options;
+    }
+    /* Setup cookie Banner */
+    setupCookieBanner(unidadeBasePath) {
+        if (isPlatformBrowser(this.platformId)) {
+            const banner = this.configOptions?.cookieBanners?.find((banner) => banner.basePath.includes(unidadeBasePath));
+            if (banner) {
+                this.addCookieBanner(banner);
+            }
+        }
+    }
+    openCookieBanner() {
+        if (this.cookieConsent && this.cookieBannerScriptElement) {
+            this.cookieConsent.privacyToolsShowCookieNotice();
+        }
+    }
+    /* Add cookie banner style and script */
+    addCookieBanner(banner) {
+        this.cookieBannerScriptElement = null;
+        this.addCookieBannerStyle(banner.styleSrc);
+        this.addCookieBannerScript(banner.scriptSrc);
+    }
+    /* Add cookie banner style. */
+    addCookieBannerStyle(src) {
+        if (isPlatformServer(this.platformId))
+            return;
+        this.document.getElementById('byRemovePortal')?.remove();
+        const oldStyle = this.document.getElementById(this.cookieBannerStyleId);
+        if (oldStyle) {
+            oldStyle.remove();
+        }
+        const style = this.document.createElement('link');
+        style.id = this.cookieBannerStyleId;
+        style.rel = 'stylesheet';
+        style.type = 'text/css';
+        style.href = src;
+        style.media = 'none';
+        style.addEventListener('load', () => {
+            style.media = 'all';
+        });
+        this.document.body.appendChild(style);
+    }
+    /* Add cookie banner script. */
+    addCookieBannerScript(src) {
+        if (isPlatformServer(this.platformId) || typeof window === 'undefined')
+            return;
+        window['cookieconsent'] = null;
+        const oldScript = this.document.getElementById(this.cookieBannerScriptId);
+        if (oldScript) {
+            oldScript.remove();
+        }
+        const script = this.document.createElement('script');
+        script.id = this.cookieBannerScriptId;
+        script.src = src;
+        script.addEventListener('load', () => {
+            this.cookieBannerScriptElement = script;
+            this.cookieConsent = window['cookieconsent'];
+            window['portalBanner']?.call();
+        });
+        this.document.body.appendChild(script);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PrivacyToolsService, deps: [{ token: DOCUMENT }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PrivacyToolsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PrivacyToolsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"privacy-tools.service.js","sourceRoot":"","sources":["../../../../../../projects/site-front-end-lib/src/lib/services/privacy-tools/privacy-tools.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT, isPlatformBrowser, isPlatformServer } from '@angular/common';\r\nimport { Inject, Injectable, PLATFORM_ID } from '@angular/core';\r\nimport { PrivacyToolsConfigOptions, PrivacyToolsCookieBanner } from '../../models/privacy-tools/privacy-tools.model';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class PrivacyToolsService {\r\n  cookieBannerScriptId = 'PrivacyToolsScript';\r\n  cookieBannerStyleId = 'PrivacyToolsStyle';\r\n  cookieBannerScriptElement: HTMLScriptElement | null = null;\r\n  configOptions: PrivacyToolsConfigOptions = {};\r\n  cookieConsent: any = null;\r\n\r\n  constructor(\r\n    @Inject(DOCUMENT) public document: Document,\r\n    @Inject(PLATFORM_ID) public platformId: object,\r\n  ) {}\r\n\r\n  /* Config */\r\n  public config(options: PrivacyToolsConfigOptions) {\r\n    this.configOptions = options;\r\n  }\r\n\r\n  /* Setup cookie Banner */\r\n  public setupCookieBanner(unidadeBasePath: string) {\r\n    if (isPlatformBrowser(this.platformId)) {\r\n      const banner = this.configOptions?.cookieBanners?.find((banner) => banner.basePath.includes(unidadeBasePath));\r\n\r\n      if (banner) {\r\n        this.addCookieBanner(banner);\r\n      }\r\n    }\r\n  }\r\n\r\n  public openCookieBanner() {\r\n    if (this.cookieConsent && this.cookieBannerScriptElement) {\r\n      this.cookieConsent.privacyToolsShowCookieNotice();\r\n    }\r\n  }\r\n\r\n  /* Add cookie banner style and script */\r\n  private addCookieBanner(banner: PrivacyToolsCookieBanner) {\r\n    this.cookieBannerScriptElement = null;\r\n    this.addCookieBannerStyle(banner.styleSrc);\r\n    this.addCookieBannerScript(banner.scriptSrc);\r\n  }\r\n\r\n  /* Add cookie banner style. */\r\n  public addCookieBannerStyle(src: string) {\r\n    if (isPlatformServer(this.platformId)) return;\r\n\r\n    this.document.getElementById('byRemovePortal')?.remove();\r\n\r\n    const oldStyle = this.document.getElementById(this.cookieBannerStyleId);\r\n\r\n    if (oldStyle) {\r\n      oldStyle.remove();\r\n    }\r\n\r\n    const style = this.document.createElement('link');\r\n    style.id = this.cookieBannerStyleId;\r\n    style.rel = 'stylesheet';\r\n    style.type = 'text/css';\r\n    style.href = src;\r\n    style.media = 'none';\r\n\r\n    style.addEventListener('load', () => {\r\n      style.media = 'all';\r\n    });\r\n\r\n    this.document.body.appendChild(style);\r\n  }\r\n\r\n  /* Add cookie banner script. */\r\n  public addCookieBannerScript(src: string) {\r\n    if (isPlatformServer(this.platformId) || typeof window === 'undefined') return;\r\n\r\n    (window as any)['cookieconsent'] = null;\r\n\r\n    const oldScript = this.document.getElementById(this.cookieBannerScriptId);\r\n\r\n    if (oldScript) {\r\n      oldScript.remove();\r\n    }\r\n    const script = this.document.createElement('script');\r\n    script.id = this.cookieBannerScriptId;\r\n    script.src = src;\r\n\r\n    script.addEventListener('load', () => {\r\n      this.cookieBannerScriptElement = script;\r\n      this.cookieConsent = (window as any)['cookieconsent'];\r\n      (window as any)['portalBanner']?.call();\r\n    });\r\n\r\n    this.document.body.appendChild(script);\r\n  }\r\n}\r\n"]}