@senior-gestao-empresarial/angular-components 7.29.1 → 8.0.0

package/esm2022/websocket/lib/models/primitive-manager.mjs

@@ -0,0 +1,35 @@
+import { BehaviorSubject, Subject } from 'rxjs';
+export class PrimitiveManager {
+    constructor(domain, service, primitive) {
+        this.domain = domain;
+        this.service = service;
+        this.primitive = primitive;
+        this.stompSubscriptions = [];
+        this.event$ = new Subject();
+        this.subscribed$ = new BehaviorSubject(false);
+    }
+    unsubscribe() {
+        this.event$.complete();
+        for (const stompSubscription of this.stompSubscriptions) {
+            stompSubscription.unsubscribe();
+        }
+        this.subscribed$.complete();
+    }
+    fireEvent(event) {
+        this.event$.next(event);
+    }
+    subscribe(...subscriptions) {
+        this.stompSubscriptions.push(...subscriptions);
+        this.subscribed$.next(true);
+    }
+    getEventObservable() {
+        return this.event$.asObservable();
+    }
+    getSubscriptionObservable() {
+        return this.subscribed$.asObservable();
+    }
+    getObserversCount() {
+        return this.event$.observers.length;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/websocket/lib/protocols/index.mjs

@@ -0,0 +1,3 @@
+export * from './on-event-options';
+export * from './primitive-event';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbnItZXJweC1hbmd1bGFyLWNvbXBvbmVudHMvd2Vic29ja2V0L3NyYy9saWIvcHJvdG9jb2xzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxtQkFBbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vb24tZXZlbnQtb3B0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL3ByaW1pdGl2ZS1ldmVudCc7XG4iXX0=

package/esm2022/websocket/lib/protocols/on-event-options.mjs

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

package/esm2022/websocket/lib/protocols/primitive-event.mjs

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

package/esm2022/websocket/lib/user-information.service.mjs

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import { get as getCookie } from 'js-cookie';
+import * as i0 from "@angular/core";
+export class UserInformationService {
+    static { this.BASE_URL_COOKIE_KEY = 'com.senior.base.url'; }
+    static { this.TOKEN_COOKIE_KEY = 'com.senior.token'; }
+    getAuthToken() {
+        const cookieValue = getCookie(UserInformationService.TOKEN_COOKIE_KEY) ?? '{}';
+        const authToken = JSON.parse(cookieValue);
+        return authToken.access_token;
+    }
+    getTenantDomain() {
+        const cookieValue = getCookie(UserInformationService.TOKEN_COOKIE_KEY) ?? '{}';
+        const authToken = JSON.parse(cookieValue);
+        return authToken.username?.split('@')[1];
+    }
+    getWebSocketUrl() {
+        let baseUrl = getCookie(UserInformationService.BASE_URL_COOKIE_KEY);
+        if (baseUrl && !baseUrl.endsWith('/')) {
+            baseUrl += '/';
+        }
+        return (baseUrl ?? '') + 'websocket';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UserInformationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UserInformationService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UserInformationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/websocket/lib/websocket.service.mjs

@@ -0,0 +1,334 @@
+import { Injectable, inject } from '@angular/core';
+import { filter, finalize, map, switchMap, take } from 'rxjs/operators';
+import { Client, FrameImpl, } from '@stomp/stompjs';
+import { BehaviorSubject, Subject } from 'rxjs';
+import SockJS from 'sockjs-client';
+import { AsyncLock } from '@senior-gestao-empresarial/angular-components/utils';
+import { UserInformationService } from './user-information.service';
+import { PrimitiveManager } from './models';
+import * as i0 from "@angular/core";
+const RECONNECT_INTERVAL_MILLISECONDS = 3000;
+const CONNECTION_TIMEOUT_MILLISECONDS = 5000;
+export class WebsocketService {
+    constructor() {
+        this.userInformationService = inject(UserInformationService);
+        this.connected$ = new BehaviorSubject(false);
+        this.disconnected$ = new Subject();
+        this.reconnected$ = new Subject();
+        this.error$ = new Subject();
+        this.subscribed$ = new Subject();
+        this.primitiveManagers = new Map();
+        this.connectionLock = new AsyncLock();
+        this.debugEnable = false;
+        this.lostConnection = false;
+    }
+    /**
+     * Enables stompjs debug logs and additional info
+     */
+    enableDebugLogs() {
+        this.debugEnable = true;
+    }
+    /**
+     * Manually starts the connection
+     */
+    async connect() {
+        await this.connectionLock.acquire();
+        try {
+            if (this.isConnected() || this.isConnecting()) {
+                return;
+            }
+            this.lostConnection = false;
+            const stompConfig = {
+                webSocketFactory: () => {
+                    return new SockJS(this.getSubscriptionUrl(), null, {
+                        timeout: CONNECTION_TIMEOUT_MILLISECONDS,
+                    });
+                },
+                connectionTimeout: CONNECTION_TIMEOUT_MILLISECONDS,
+                reconnectDelay: RECONNECT_INTERVAL_MILLISECONDS,
+                debug: this.debug.bind(this),
+                onConnect: this.handleOnConnected.bind(this),
+                onDisconnect: this.handleOnDisconnect.bind(this),
+                onWebSocketClose: this.handleOnWebSocketClose.bind(this),
+                onStompError: this.handleOnStompError.bind(this),
+                onWebSocketError: this.handleOnWebSocketError.bind(this),
+            };
+            this.debug('Connecting the Webscoket');
+            this.stompClient = new Client(stompConfig);
+            this.stompClient.activate();
+        }
+        finally {
+            await this.connectionLock.release();
+        }
+    }
+    /**
+     * Manually disconnect the websocket. The reconnect loop will be stopped.
+     */
+    async disconnect() {
+        if (!this.isConnected()) {
+            return;
+        }
+        await this.connectionLock.acquire();
+        try {
+            for (const primitiveManager of this.primitiveManagers.values()) {
+                primitiveManager.unsubscribe();
+            }
+            this.primitiveManagers.clear();
+            this.connected$.next(false);
+            if (this.stompClient) {
+                await this.stompClient.deactivate();
+            }
+        }
+        finally {
+            await this.connectionLock.release();
+        }
+    }
+    /**
+     * Check if the websocket is connected
+     * @return `boolean` representing if the websocket is connected
+     */
+    isConnected() {
+        if (!this.stompClient) {
+            return false;
+        }
+        return this.stompClient.connected;
+    }
+    /**
+     * Check if the websocket is tring to connect
+     * @return `boolean` representing if the websocket status
+     */
+    isConnecting() {
+        if (!this.stompClient) {
+            return false;
+        }
+        return !this.stompClient.connected && this.stompClient.active;
+    }
+    /**
+     * Event responsable to emit an event when the connection is established.
+     * Do not forget to unsubscribe the observable when you don't need it anymore.
+     * @return `Observable<boolean>`
+     */
+    onConnect() {
+        return this.connected$.asObservable().pipe(filter((p) => p === true));
+    }
+    /**
+     * Event responsable to emit an event when the connection is closed.
+     * Do not forget to unsubscribe the observable when you don't need it anymore.
+     * @return `Observable<void>`
+     */
+    onDisconnect() {
+        return this.disconnected$.asObservable();
+    }
+    /**
+     * Event responsable to emit an event when the connection is reestablished.
+     * Do not forget to unsubscribe the observable when you don't need it anymore.
+     * @return `Observable<void>`
+     */
+    onReconnect() {
+        return this.reconnected$.asObservable();
+    }
+    /**
+     * Event responsable to emit an event when an error ocurred.
+     * Do not forget to unsubscribe the observable when you don't need it anymore.
+     * @return `Observable<FrameImpl>`
+     */
+    onError() {
+        return this.error$.asObservable();
+    }
+    /**
+     * Event responsible to emit an event when a primitive is called.
+     * Do not forget to unsubscribe the observable when you don't need it anymore.
+     * @typeParam `<T>` Object type that will be used in the observable for the `data` property.
+     * @param {OnEventOptions} options Configurations for the event.
+     * @return `Observable<PrimitiveEvent<T>>` Observable that emits an event when the service calls the primitive.
+     */
+    onEvent(options) {
+        const { domain, service, primitive } = options;
+        const key = this.buildPrimitiveManagerKey(domain, service, primitive);
+        const existingPrimitiveManager = this.primitiveManagers.get(key);
+        if (existingPrimitiveManager) {
+            return existingPrimitiveManager.getEventObservable();
+        }
+        const primitiveManager = new PrimitiveManager(domain, service, primitive);
+        this.primitiveManagers.set(key, primitiveManager);
+        void this.connect().then(() => {
+            this.onConnect()
+                .pipe(take(1))
+                .subscribe(() => {
+                this.createStompSubscriptions(primitiveManager);
+            });
+        });
+        return primitiveManager
+            .getEventObservable()
+            .pipe(finalize(() => void this.unsubscribePrimitiveOnFinalize(primitiveManager)));
+    }
+    /**
+     * Event responsible to emit an event when a subscription is created for the primitive.
+     * Do not forget to unsubscribe the observable when you don't need it anymore.
+     * @param {OnEventOptions} options Configurations for the event.
+     * Observable responsável por emitir uma notificação após o subscribe do evento pela primeira vez.
+     * @return `Observable<boolean>` Observable that emits an event when the service calls the primitive.
+     */
+    onSubscribe(options) {
+        const { domain, service, primitive } = options;
+        const key = this.buildPrimitiveManagerKey(domain, service, primitive);
+        return this.onConnect().pipe(take(1), switchMap(() => {
+            const existingPrimitiveManager = this.primitiveManagers.get(key);
+            if (existingPrimitiveManager) {
+                return existingPrimitiveManager
+                    .getSubscriptionObservable()
+                    .pipe(take(1));
+            }
+            return this.subscribed$.asObservable().pipe(filter((primitiveManager) => {
+                return (this.buildPrimitiveManagerKey(primitiveManager.domain, primitiveManager.service, primitiveManager.primitive) === key);
+            }), map(() => true), take(1));
+        }));
+    }
+    debug(message, ...optionalParams) {
+        if (!this.debugEnable) {
+            return;
+        }
+        console.warn('WS debug: ' + message, ...optionalParams);
+    }
+    info(message) {
+        console.warn('WS info: ' + message);
+    }
+    handleOnConnected() {
+        this.info('Webscoket connected');
+        this.connected$.next(true);
+        if (this.lostConnection) {
+            this.info('Webscoket reconnected, recriating subscriptions');
+            this.handleReconnection();
+        }
+    }
+    handleOnDisconnect() {
+        this.info('Webscoket disconnected');
+        this.connected$.next(false);
+        this.disconnected$.next();
+    }
+    handleOnWebSocketClose(data) {
+        if (data?.reason === '') {
+            this.lostConnection = true;
+            this.handleError('Failed to send message to ExecutorSubscribableChannel', new FrameImpl({
+                command: data.type,
+                headers: {
+                    message: data.reason,
+                },
+            }));
+            return;
+        }
+        if (data?.reason?.toLowerCase().indexOf('go away') !== -1) {
+            this.lostConnection = true;
+            this.handleError('AuthenticationError', new FrameImpl({
+                command: data.type,
+                headers: {
+                    message: data.reason,
+                },
+            }));
+            return;
+        }
+        if (data?.reason?.toLowerCase().indexOf('cannot connect to server') !==
+            -1) {
+            this.lostConnection = true;
+            this.handleError('ConnectionError', new FrameImpl({
+                command: data.type,
+                headers: {
+                    message: data.reason,
+                },
+            }));
+            return;
+        }
+        if (data.wasClean) {
+            return;
+        }
+        this.lostConnection = true;
+    }
+    handleOnStompError(data) {
+        this.handleError('StompError', data);
+        if (this.isAuthenticationError(data)) {
+            this.info('Authentication error, recriating subscriptions');
+            this.handleReconnection();
+        }
+    }
+    isAuthenticationError(data) {
+        const errorMessage = data?.headers?.['message'];
+        if (!errorMessage) {
+            return false;
+        }
+        return errorMessage.toLowerCase().indexOf('forbiddenexception') !== -1;
+    }
+    handleOnWebSocketError(data) {
+        this.handleError('WebSocketError', data);
+    }
+    handleError(origin, data) {
+        console.error(origin, data);
+        this.error$.next(data);
+    }
+    handleReconnection() {
+        this.lostConnection = false;
+        this.reconnectPrimitives();
+        this.reconnected$.next();
+    }
+    reconnectPrimitives() {
+        for (const primitiveManager of this.primitiveManagers.values()) {
+            this.createStompSubscriptions(primitiveManager);
+        }
+    }
+    buildSubscriptionUrlWithToken(domain, service, primitive) {
+        const authToken = this.userInformationService.getAuthToken();
+        const tenant = this.userInformationService.getTenantDomain();
+        return `/topic/${tenant}/${authToken}/${domain}/${service}/${primitive}`;
+    }
+    getSubscriptionUrlWithoutToken(domain, service, primitive) {
+        const tenant = this.userInformationService.getTenantDomain();
+        return `/topic/${tenant}/${domain}/${service}/${primitive}`;
+    }
+    buildPrimitiveManagerKey(domain, service, primitive) {
+        return `${domain}/${service}/${primitive}`;
+    }
+    async unsubscribePrimitiveOnFinalize(primitiveManager) {
+        primitiveManager.unsubscribe();
+        const key = this.buildPrimitiveManagerKey(primitiveManager.domain, primitiveManager.service, primitiveManager.primitive);
+        this.primitiveManagers.delete(key);
+        await this.disconnectIfNoMoreObservables();
+    }
+    async disconnectIfNoMoreObservables() {
+        if (this.getObserversCount() === 0) {
+            this.debug('Manually disconnecting because there are no more observers');
+            await this.disconnect();
+        }
+    }
+    getObserversCount() {
+        let observersCount = 0;
+        this.primitiveManagers.forEach((primitiveManager) => {
+            observersCount += primitiveManager.getObserversCount();
+        });
+        return observersCount;
+    }
+    createStompSubscription(destination, primitiveManager) {
+        return this.stompClient.subscribe(destination, (message) => {
+            const event = JSON.parse(message.body || '{}');
+            primitiveManager.fireEvent(event);
+        });
+    }
+    createStompSubscriptions(primitiveManager) {
+        const subscriptionUrlWithToken = this.buildSubscriptionUrlWithToken(primitiveManager.domain, primitiveManager.service, primitiveManager.primitive);
+        const subscriptionUrlWithoutToken = this.getSubscriptionUrlWithoutToken(primitiveManager.domain, primitiveManager.service, primitiveManager.primitive);
+        const stompSubscriptionWithToken = this.createStompSubscription(subscriptionUrlWithToken, primitiveManager);
+        const stompSubscriptionWithoutToken = this.createStompSubscription(subscriptionUrlWithoutToken, primitiveManager);
+        primitiveManager.subscribe(stompSubscriptionWithToken, stompSubscriptionWithoutToken);
+        this.subscribed$.next(primitiveManager);
+    }
+    getSubscriptionUrl() {
+        return `${this.userInformationService.getWebSocketUrl()}/subscription`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WebsocketService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WebsocketService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: WebsocketService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket.service.js","sourceRoot":"","sources":["../../../../projects/snr-erpx-angular-components/websocket/src/lib/websocket.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { filter, finalize, map, switchMap, take } from 'rxjs/operators';\nimport {\n    IFrame,\n    StompConfig,\n    StompSubscription,\n    Client,\n    FrameImpl,\n} from '@stomp/stompjs';\nimport { BehaviorSubject, Subject, Observable } from 'rxjs';\nimport SockJS from 'sockjs-client';\nimport { AsyncLock } from '@senior-gestao-empresarial/angular-components/utils';\nimport { UserInformationService } from './user-information.service';\nimport { PrimitiveManager } from './models';\nimport { OnEventOptions, PrimitiveEvent } from './protocols';\n\nconst RECONNECT_INTERVAL_MILLISECONDS = 3000;\nconst CONNECTION_TIMEOUT_MILLISECONDS = 5000;\n\n@Injectable({\n    providedIn: 'root',\n})\nexport class WebsocketService {\n    private readonly userInformationService = inject(UserInformationService);\n\n    private readonly connected$ = new BehaviorSubject<boolean>(false);\n    private readonly disconnected$ = new Subject<void>();\n    private readonly reconnected$ = new Subject<void>();\n    private readonly error$ = new Subject<IFrame>();\n    private readonly subscribed$ = new Subject<PrimitiveManager<any>>();\n\n    private readonly primitiveManagers: Map<string, PrimitiveManager<any>> =\n        new Map<string, PrimitiveManager<any>>();\n    private readonly connectionLock = new AsyncLock();\n\n    private stompClient!: Client;\n    private debugEnable = false;\n    private lostConnection = false;\n\n    /**\n     * Enables stompjs debug logs and additional info\n     */\n    public enableDebugLogs(): void {\n        this.debugEnable = true;\n    }\n\n    /**\n     * Manually starts the connection\n     */\n    public async connect(): Promise<void> {\n        await this.connectionLock.acquire();\n\n        try {\n            if (this.isConnected() || this.isConnecting()) {\n                return;\n            }\n            this.lostConnection = false;\n\n            const stompConfig: StompConfig = {\n                webSocketFactory: () => {\n                    return new SockJS(this.getSubscriptionUrl(), null, {\n                        timeout: CONNECTION_TIMEOUT_MILLISECONDS,\n                    });\n                },\n                connectionTimeout: CONNECTION_TIMEOUT_MILLISECONDS,\n                reconnectDelay: RECONNECT_INTERVAL_MILLISECONDS,\n                debug: this.debug.bind(this),\n                onConnect: this.handleOnConnected.bind(this),\n                onDisconnect: this.handleOnDisconnect.bind(this),\n                onWebSocketClose: this.handleOnWebSocketClose.bind(this),\n                onStompError: this.handleOnStompError.bind(this),\n                onWebSocketError: this.handleOnWebSocketError.bind(this),\n            };\n\n            this.debug('Connecting the Webscoket');\n\n            this.stompClient = new Client(stompConfig);\n            this.stompClient.activate();\n        } finally {\n            await this.connectionLock.release();\n        }\n    }\n\n    /**\n     * Manually disconnect the websocket. The reconnect loop will be stopped.\n     */\n    public async disconnect(): Promise<void> {\n        if (!this.isConnected()) {\n            return;\n        }\n\n        await this.connectionLock.acquire();\n        try {\n            for (const primitiveManager of this.primitiveManagers.values()) {\n                primitiveManager.unsubscribe();\n            }\n\n            this.primitiveManagers.clear();\n            this.connected$.next(false);\n\n            if (this.stompClient) {\n                await this.stompClient.deactivate();\n            }\n        } finally {\n            await this.connectionLock.release();\n        }\n    }\n\n    /**\n     * Check if the websocket is connected\n     * @return `boolean` representing if the websocket is connected\n     */\n    public isConnected(): boolean {\n        if (!this.stompClient) {\n            return false;\n        }\n\n        return this.stompClient.connected;\n    }\n\n    /**\n     * Check if the websocket is tring to connect\n     * @return `boolean` representing if the websocket status\n     */\n    public isConnecting(): boolean {\n        if (!this.stompClient) {\n            return false;\n        }\n\n        return !this.stompClient.connected && this.stompClient.active;\n    }\n\n    /**\n     * Event responsable to emit an event when the connection is established.\n     * Do not forget to unsubscribe the observable when you don't need it anymore.\n     * @return `Observable<boolean>`\n     */\n    public onConnect(): Observable<boolean> {\n        return this.connected$.asObservable().pipe(filter((p) => p === true));\n    }\n\n    /**\n     * Event responsable to emit an event when the connection is closed.\n     * Do not forget to unsubscribe the observable when you don't need it anymore.\n     * @return `Observable<void>`\n     */\n    public onDisconnect(): Observable<void> {\n        return this.disconnected$.asObservable();\n    }\n\n    /**\n     * Event responsable to emit an event when the connection is reestablished.\n     * Do not forget to unsubscribe the observable when you don't need it anymore.\n     * @return `Observable<void>`\n     */\n    public onReconnect(): Observable<void> {\n        return this.reconnected$.asObservable();\n    }\n\n    /**\n     * Event responsable to emit an event when an error ocurred.\n     * Do not forget to unsubscribe the observable when you don't need it anymore.\n     * @return `Observable<FrameImpl>`\n     */\n    public onError(): Observable<IFrame> {\n        return this.error$.asObservable();\n    }\n\n    /**\n     * Event responsible to emit an event when a primitive is called.\n     * Do not forget to unsubscribe the observable when you don't need it anymore.\n     * @typeParam `<T>` Object type that will be used in the observable for the `data` property.\n     * @param {OnEventOptions} options Configurations for the event.\n     * @return `Observable<PrimitiveEvent<T>>` Observable that emits an event when the service calls the primitive.\n     */\n    public onEvent<T>(options: OnEventOptions): Observable<PrimitiveEvent<T>> {\n        const { domain, service, primitive } = options;\n        const key = this.buildPrimitiveManagerKey(domain, service, primitive);\n\n        const existingPrimitiveManager = this.primitiveManagers.get(key);\n        if (existingPrimitiveManager) {\n            return existingPrimitiveManager.getEventObservable();\n        }\n\n        const primitiveManager = new PrimitiveManager<T>(\n            domain,\n            service,\n            primitive\n        );\n        this.primitiveManagers.set(key, primitiveManager);\n\n        void this.connect().then(() => {\n            this.onConnect()\n                .pipe(take(1))\n                .subscribe(() => {\n                    this.createStompSubscriptions(primitiveManager);\n                });\n        });\n\n        return primitiveManager\n            .getEventObservable()\n            .pipe(\n                finalize(\n                    () =>\n                        void this.unsubscribePrimitiveOnFinalize(\n                            primitiveManager\n                        )\n                )\n            );\n    }\n\n    /**\n     * Event responsible to emit an event when a subscription is created for the primitive.\n     * Do not forget to unsubscribe the observable when you don't need it anymore.\n     * @param {OnEventOptions} options Configurations for the event.\n     * Observable responsável por emitir uma notificação após o subscribe do evento pela primeira vez.\n     * @return `Observable<boolean>` Observable that emits an event when the service calls the primitive.\n     */\n    public onSubscribe(options: OnEventOptions): Observable<boolean> {\n        const { domain, service, primitive } = options;\n        const key = this.buildPrimitiveManagerKey(domain, service, primitive);\n\n        return this.onConnect().pipe(\n            take(1),\n            switchMap(() => {\n                const existingPrimitiveManager =\n                    this.primitiveManagers.get(key);\n                if (existingPrimitiveManager) {\n                    return existingPrimitiveManager\n                        .getSubscriptionObservable()\n                        .pipe(take(1));\n                }\n\n                return this.subscribed$.asObservable().pipe(\n                    filter((primitiveManager) => {\n                        return (\n                            this.buildPrimitiveManagerKey(\n                                primitiveManager.domain,\n                                primitiveManager.service,\n                                primitiveManager.primitive\n                            ) === key\n                        );\n                    }),\n                    map(() => true),\n                    take(1)\n                );\n            })\n        );\n    }\n\n    private debug(message: string, ...optionalParams: unknown[]): void {\n        if (!this.debugEnable) {\n            return;\n        }\n        console.warn('WS debug: ' + message, ...optionalParams);\n    }\n\n    private info(message: string): void {\n        console.warn('WS info: ' + message);\n    }\n\n    private handleOnConnected(): void {\n        this.info('Webscoket connected');\n\n        this.connected$.next(true);\n        if (this.lostConnection) {\n            this.info('Webscoket reconnected, recriating subscriptions');\n            this.handleReconnection();\n        }\n    }\n\n    private handleOnDisconnect(): void {\n        this.info('Webscoket disconnected');\n\n        this.connected$.next(false);\n        this.disconnected$.next();\n    }\n\n    private handleOnWebSocketClose(data: CloseEvent): void {\n        if (data?.reason === '') {\n            this.lostConnection = true;\n            this.handleError(\n                'Failed to send message to ExecutorSubscribableChannel',\n                new FrameImpl({\n                    command: data.type,\n                    headers: {\n                        message: data.reason,\n                    },\n                })\n            );\n            return;\n        }\n\n        if (data?.reason?.toLowerCase().indexOf('go away') !== -1) {\n            this.lostConnection = true;\n            this.handleError(\n                'AuthenticationError',\n                new FrameImpl({\n                    command: data.type,\n                    headers: {\n                        message: data.reason,\n                    },\n                })\n            );\n            return;\n        }\n\n        if (\n            data?.reason?.toLowerCase().indexOf('cannot connect to server') !==\n            -1\n        ) {\n            this.lostConnection = true;\n            this.handleError(\n                'ConnectionError',\n                new FrameImpl({\n                    command: data.type,\n                    headers: {\n                        message: data.reason,\n                    },\n                })\n            );\n            return;\n        }\n\n        if (data.wasClean) {\n            return;\n        }\n\n        this.lostConnection = true;\n    }\n\n    private handleOnStompError(data: IFrame): void {\n        this.handleError('StompError', data);\n\n        if (this.isAuthenticationError(data)) {\n            this.info('Authentication error, recriating subscriptions');\n            this.handleReconnection();\n        }\n    }\n\n    private isAuthenticationError(data: IFrame): boolean {\n        const errorMessage = data?.headers?.['message'];\n        if (!errorMessage) {\n            return false;\n        }\n\n        return errorMessage.toLowerCase().indexOf('forbiddenexception') !== -1;\n    }\n\n    private handleOnWebSocketError(data: unknown): void {\n        this.handleError('WebSocketError', data as IFrame);\n    }\n\n    private handleError(origin: string, data: IFrame): void {\n        console.error(origin, data);\n        this.error$.next(data);\n    }\n\n    private handleReconnection(): void {\n        this.lostConnection = false;\n        this.reconnectPrimitives();\n        this.reconnected$.next();\n    }\n\n    private reconnectPrimitives(): void {\n        for (const primitiveManager of this.primitiveManagers.values()) {\n            this.createStompSubscriptions(primitiveManager);\n        }\n    }\n\n    private buildSubscriptionUrlWithToken(\n        domain: string,\n        service: string,\n        primitive: string\n    ): string {\n        const authToken = this.userInformationService.getAuthToken();\n        const tenant = this.userInformationService.getTenantDomain();\n        return `/topic/${tenant}/${authToken}/${domain}/${service}/${primitive}`;\n    }\n\n    private getSubscriptionUrlWithoutToken(\n        domain: string,\n        service: string,\n        primitive: string\n    ): string {\n        const tenant = this.userInformationService.getTenantDomain();\n        return `/topic/${tenant}/${domain}/${service}/${primitive}`;\n    }\n\n    private buildPrimitiveManagerKey(\n        domain: string,\n        service: string,\n        primitive: string\n    ): string {\n        return `${domain}/${service}/${primitive}`;\n    }\n\n    private async unsubscribePrimitiveOnFinalize(\n        primitiveManager: PrimitiveManager<any>\n    ): Promise<void> {\n        primitiveManager.unsubscribe();\n\n        const key = this.buildPrimitiveManagerKey(\n            primitiveManager.domain,\n            primitiveManager.service,\n            primitiveManager.primitive\n        );\n\n        this.primitiveManagers.delete(key);\n\n        await this.disconnectIfNoMoreObservables();\n    }\n\n    private async disconnectIfNoMoreObservables(): Promise<void> {\n        if (this.getObserversCount() === 0) {\n            this.debug(\n                'Manually disconnecting because there are no more observers'\n            );\n            await this.disconnect();\n        }\n    }\n\n    private getObserversCount(): number {\n        let observersCount = 0;\n\n        this.primitiveManagers.forEach((primitiveManager) => {\n            observersCount += primitiveManager.getObserversCount();\n        });\n\n        return observersCount;\n    }\n\n    private createStompSubscription<T>(\n        destination: string,\n        primitiveManager: PrimitiveManager<T>\n    ): StompSubscription {\n        return this.stompClient.subscribe(destination, (message) => {\n            const event = JSON.parse(message.body || '{}');\n            primitiveManager.fireEvent(event);\n        });\n    }\n\n    private createStompSubscriptions<T>(\n        primitiveManager: PrimitiveManager<T>\n    ): void {\n        const subscriptionUrlWithToken = this.buildSubscriptionUrlWithToken(\n            primitiveManager.domain,\n            primitiveManager.service,\n            primitiveManager.primitive\n        );\n        const subscriptionUrlWithoutToken = this.getSubscriptionUrlWithoutToken(\n            primitiveManager.domain,\n            primitiveManager.service,\n            primitiveManager.primitive\n        );\n\n        const stompSubscriptionWithToken = this.createStompSubscription(\n            subscriptionUrlWithToken,\n            primitiveManager\n        );\n        const stompSubscriptionWithoutToken = this.createStompSubscription(\n            subscriptionUrlWithoutToken,\n            primitiveManager\n        );\n        primitiveManager.subscribe(\n            stompSubscriptionWithToken,\n            stompSubscriptionWithoutToken\n        );\n        this.subscribed$.next(primitiveManager);\n    }\n\n    private getSubscriptionUrl(): string {\n        return `${this.userInformationService.getWebSocketUrl()}/subscription`;\n    }\n}\n"]}

package/esm2022/websocket/public-api.mjs

@@ -0,0 +1,4 @@
+export * from './lib/websocket.service';
+export * from './lib/models/index';
+export * from './lib/protocols/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3Nuci1lcnB4LWFuZ3VsYXItY29tcG9uZW50cy93ZWJzb2NrZXQvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsdUJBQXVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi93ZWJzb2NrZXQuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9tb2RlbHMvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcHJvdG9jb2xzL2luZGV4JztcbiJdfQ==

package/esm2022/websocket/senior-gestao-empresarial-angular-components-websocket.mjs

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

package/fesm2022/senior-gestao-empresarial-angular-components-breadcrumb.mjs

@@ -0,0 +1,122 @@
+import * as i0 from '@angular/core';
+import { inject, Component, Input, NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { BreadcrumbModule as BreadcrumbModule$1 } from 'primeng/breadcrumb';
+import { ActivatedRoute, Router, NavigationEnd, PRIMARY_OUTLET, RouterModule } from '@angular/router';
+import { Subject } from 'rxjs';
+import { takeUntil, filter } from 'rxjs/operators';
+
+class BreadcrumbComponent {
+    constructor() {
+        this.activatedRoute = inject(ActivatedRoute);
+        this.router = inject(Router);
+        this.ngUnsubscribe = new Subject();
+        this.router.events
+            .pipe(takeUntil(this.ngUnsubscribe), filter((event) => event instanceof NavigationEnd))
+            .subscribe(() => this.onNavigationEnd());
+    }
+    ngOnDestroy() {
+        this.ngUnsubscribe.next();
+        this.ngUnsubscribe.complete();
+    }
+    onNavigationEnd() {
+        const currentRoute = this.activatedRoute.root;
+        const validRoutes = this.getValidChildren(currentRoute);
+        this.title = this.getCurrentTitle(validRoutes);
+        this.home = this.getCurrentHome(validRoutes);
+        this.items = this.getCurrentItems(validRoutes);
+    }
+    getValidChildren(route) {
+        const valid = route.routeConfig?.path &&
+            route.routeConfig.component &&
+            route.outlet === PRIMARY_OUTLET;
+        return route.children.reduce((validRoutes, child) => [
+            ...validRoutes,
+            ...this.getValidChildren(child),
+        ], valid ? [route] : []);
+    }
+    getCurrentTitle(routes) {
+        const last = routes[routes.length - 1];
+        if (last?.routeConfig) {
+            return this.getTitle(last);
+        }
+        return undefined;
+    }
+    getCurrentHome(routes) {
+        let home;
+        if (this.homeUrl) {
+            home = { url: this.homeUrl, icon: 'fa fa-home' };
+        }
+        else if (routes.length) {
+            home = {
+                ...this.getMenuItem(routes[0], routes.length === 1),
+                icon: 'fa fa-home',
+            };
+        }
+        return home;
+    }
+    getCurrentItems(routes) {
+        if (!routes.length) {
+            return undefined;
+        }
+        const items = this.homeUrl ? routes : routes.slice(1);
+        if (items.length) {
+            return items.map((route, i) => this.getMenuItem(route, i === routes.length - 1));
+        }
+        return undefined;
+    }
+    getMenuItem(route, disabled = false) {
+        const label = this.getTitle(route);
+        const routes = route.pathFromRoot;
+        const routerLink = routes
+            .slice(0, routes.indexOf(route) + 1)
+            .reduce((result, item) => [
+            ...result,
+            ...item.snapshot.url.map((url) => url.path),
+        ], ['/']);
+        return {
+            label,
+            routerLink,
+            queryParams: route.snapshot.queryParams,
+            routerLinkActiveOptions: { exact: true },
+            disabled,
+        };
+    }
+    getTitle(route) {
+        const { snapshot, routeConfig } = route;
+        const title = snapshot.data['routeTitle'];
+        if (!title) {
+            throw new Error(`No routeTitle defined for the route /${routeConfig?.path}`);
+        }
+        return title;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BreadcrumbComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: BreadcrumbComponent, selector: "s-breadcrumb", inputs: { homeUrl: "homeUrl" }, ngImport: i0, template: "" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BreadcrumbComponent, decorators: [{
+            type: Component,
+            args: [{ selector: `s-breadcrumb`, template: "" }]
+        }], ctorParameters: () => [], propDecorators: { homeUrl: [{
+                type: Input
+            }] } });
+
+class BreadcrumbModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BreadcrumbModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: BreadcrumbModule, declarations: [BreadcrumbComponent], imports: [CommonModule, BreadcrumbModule$1, RouterModule], exports: [BreadcrumbComponent, RouterModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BreadcrumbModule, imports: [CommonModule, BreadcrumbModule$1, RouterModule, RouterModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BreadcrumbModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, BreadcrumbModule$1, RouterModule],
+                    declarations: [BreadcrumbComponent],
+                    exports: [BreadcrumbComponent, RouterModule],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BreadcrumbComponent, BreadcrumbModule };
+//# sourceMappingURL=senior-gestao-empresarial-angular-components-breadcrumb.mjs.map