@senior-agronegocio/angular-components 0.0.49

package/esm2015/services/websocket/websocket.service.js

@@ -0,0 +1,339 @@
+import { __awaiter, __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { filter, finalize, map, switchMap, take } from 'rxjs/operators';
+import { Client, FrameImpl } from '@stomp/stompjs';
+import { BehaviorSubject, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./user-information.service";
+const SockJS = require('sockjs-client');
+import { AsyncLock } from './async-lock';
+import { UserInformationService } from './user-information.service';
+import { PrimitiveManager } from './models';
+const RECONNECT_INTERVAL_MILLISECONDS = 3000;
+const CONNECTION_TIMEOUT_MILLISECONDS = 5000;
+let WebsocketService = class WebsocketService {
+    constructor(userInformationService) {
+        this.userInformationService = 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
+     */
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield 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
+                        });
+                    },
+                    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 {
+                yield this.connectionLock.release();
+            }
+        });
+    }
+    /**
+     * Manually disconnect the websocket. The reconnect loop will be stopped.
+     */
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnected()) {
+                return;
+            }
+            yield this.connectionLock.acquire();
+            try {
+                for (const primitiveManager of this.primitiveManagers.values()) {
+                    primitiveManager.unsubscribe();
+                }
+                this.primitiveManagers.clear();
+                this.connected$.next(false);
+                if (this.stompClient) {
+                    yield this.stompClient.deactivate();
+                }
+            }
+            finally {
+                yield 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);
+        if (this.primitiveManagers.has(key)) {
+            return this.primitiveManagers.get(key).getEventObservable();
+        }
+        const primitiveManager = new PrimitiveManager(domain, service, primitive);
+        this.primitiveManagers.set(key, primitiveManager);
+        this.connect().then(() => {
+            this.onConnect()
+                .pipe(take(1))
+                .subscribe(() => {
+                this.createStompSubscriptions(primitiveManager);
+            });
+        });
+        return primitiveManager
+            .getEventObservable()
+            .pipe(finalize(() => 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(() => {
+            if (this.primitiveManagers.has(key)) {
+                return this.primitiveManagers
+                    .get(key)
+                    .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.log('WS debug: ' + message, ...optionalParams);
+    }
+    info(message) {
+        console.info('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) {
+        var _a, _b;
+        if (((_a = data === null || data === void 0 ? void 0 : data.reason) === null || _a === void 0 ? void 0 : _a.toLowerCase().indexOf("go away")) !== -1) {
+            this.lostConnection = true;
+            this.handleError('AuthenticationError', new FrameImpl({
+                command: data.type,
+                headers: {
+                    message: data.reason
+                }
+            }));
+            return;
+        }
+        if (((_b = data === null || data === void 0 ? void 0 : data.reason) === null || _b === void 0 ? void 0 : _b.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) {
+        var _a;
+        const errorMessage = (_a = data === null || data === void 0 ? void 0 : data.headers) === null || _a === void 0 ? void 0 : _a.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}`;
+    }
+    unsubscribePrimitiveOnFinalize(primitiveManager) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (primitiveManager.hasObservers()) {
+                return;
+            }
+            primitiveManager.unsubscribe();
+            const key = this.buildPrimitiveManagerKey(primitiveManager.domain, primitiveManager.service, primitiveManager.primitive);
+            this.primitiveManagers.delete(key);
+            yield this.disconnectIfNoMoreObservables();
+        });
+    }
+    disconnectIfNoMoreObservables() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.getObserversCount() === 0) {
+                this.debug('Manually disconnecting because there are no more observers');
+                yield 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`;
+    }
+};
+WebsocketService.ctorParameters = () => [
+    { type: UserInformationService }
+];
+WebsocketService.ɵprov = i0.ɵɵdefineInjectable({ factory: function WebsocketService_Factory() { return new WebsocketService(i0.ɵɵinject(i1.UserInformationService)); }, token: WebsocketService, providedIn: "root" });
+WebsocketService = __decorate([
+    Injectable({
+        providedIn: 'root'
+    })
+], WebsocketService);
+export { WebsocketService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket.service.js","sourceRoot":"ng://@senior-agronegocio/angular-components/","sources":["services/websocket/websocket.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAkC,MAAM,gBAAgB,CAAC;AACnF,OAAO,EAAE,eAAe,EAAc,OAAO,EAAE,MAAM,MAAM,CAAC;;;AAC5D,MAAM,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAG5C,MAAM,+BAA+B,GAAG,IAAI,CAAC;AAC7C,MAAM,+BAA+B,GAAG,IAAI,CAAC;AAK7C,IAAa,gBAAgB,GAA7B,MAAa,gBAAgB;IAczB,YAA6B,sBAA8C;QAA9C,2BAAsB,GAAtB,sBAAsB,CAAwB;QAb1D,eAAU,GAAG,IAAI,eAAe,CAAU,KAAK,CAAC,CAAC;QACjD,kBAAa,GAAG,IAAI,OAAO,EAAQ,CAAC;QACpC,iBAAY,GAAG,IAAI,OAAO,EAAQ,CAAC;QACnC,WAAM,GAAG,IAAI,OAAO,EAAa,CAAC;QAClC,gBAAW,GAAG,IAAI,OAAO,EAAyB,CAAC;QAEnD,sBAAiB,GAAuC,IAAI,GAAG,EAAiC,CAAC;QACjG,mBAAc,GAAG,IAAI,SAAS,EAAE,CAAC;QAG1C,gBAAW,GAAG,KAAK,CAAC;QACpB,mBAAc,GAAG,KAAK,CAAC;IAG/B,CAAC;IAED;;OAEG;IACI,eAAe;QAClB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;IAC5B,CAAC;IAED;;OAEG;IACU,OAAO;;YAChB,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;YAEpC,IAAI;gBACA,IAAI,IAAI,CAAC,WAAW,EAAE,IAAI,IAAI,CAAC,YAAY,EAAE,EAAE;oBAC3C,OAAO;iBACV;gBACD,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;gBAE5B,MAAM,WAAW,GAAgB;oBAC7B,gBAAgB,EAAE,GAAG,EAAE;wBACnB,OAAO,IAAI,MAAM,CACb,IAAI,CAAC,kBAAkB,EAAE,EACzB,IAAI,EACJ;4BACI,OAAO,EAAE,+BAA+B;yBAC3C,CACJ,CAAC;oBACN,CAAC;oBACD,cAAc,EAAE,+BAA+B;oBAC/C,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC;oBAC5B,SAAS,EAAE,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC;oBAC5C,YAAY,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC;oBAChD,gBAAgB,EAAE,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC;oBACxD,YAAY,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC;oBAChD,gBAAgB,EAAE,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC;iBAC3D,CAAC;gBAEF,IAAI,CAAC,KAAK,CAAC,0BAA0B,CAAC,CAAC;gBAEvC,IAAI,CAAC,WAAW,GAAG,IAAI,MAAM,CAAC,WAAW,CAAC,CAAC;gBAC3C,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;aAC/B;oBAAS;gBACN,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;aACvC;QACL,CAAC;KAAA;IAED;;OAEG;IACU,UAAU;;YACnB,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE;gBACrB,OAAO;aACV;YAED,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;YACpC,IAAI;gBACA,KAAK,MAAM,gBAAgB,IAAI,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,EAAE;oBAC5D,gBAAgB,CAAC,WAAW,EAAE,CAAC;iBAClC;gBAED,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC;gBAC/B,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAE5B,IAAI,IAAI,CAAC,WAAW,EAAE;oBAClB,MAAM,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC;iBACvC;aACJ;oBAAS;gBACN,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;aACvC;QACL,CAAC;KAAA;IAED;;;OAGG;IACI,WAAW;QACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACnB,OAAO,KAAK,CAAC;SAChB;QAED,OAAO,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;IACtC,CAAC;IAED;;;OAGG;IACI,YAAY;QACf,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACnB,OAAO,KAAK,CAAC;SAChB;QAED,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,IAAI,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC;IAClE,CAAC;IAED;;;;OAIG;IACI,SAAS;QACZ,OAAO,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE;aAChC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC;IACvC,CAAC;IAED;;;;OAIG;IACI,YAAY;QACf,OAAO,IAAI,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC;IAC7C,CAAC;IAED;;;;OAIG;IACI,WAAW;QACd,OAAO,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,CAAC;IAC5C,CAAC;IAED;;;;OAIG;IACI,OAAO;QACV,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;IACtC,CAAC;IAED;;;;;;OAMG;IACI,OAAO,CAAI,OAAuB;QACrC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC;QAC/C,MAAM,GAAG,GAAG,IAAI,CAAC,wBAAwB,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;QAEtE,IAAI,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;YACjC,OAAO,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,kBAAkB,EAAE,CAAC;SAC/D;QAED,MAAM,gBAAgB,GAAG,IAAI,gBAAgB,CAAI,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;QAC7E,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC;QAElD,IAAI,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;YACrB,IAAI,CAAC,SAAS,EAAE;iBACX,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;iBACb,SAAS,CAAC,GAAG,EAAE;gBACZ,IAAI,CAAC,wBAAwB,CAAC,gBAAgB,CAAC,CAAC;YACpD,CAAC,CAAC,CAAC;QACX,CAAC,CAAC,CAAC;QAEH,OAAO,gBAAgB;aAClB,kBAAkB,EAAE;aACpB,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,8BAA8B,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;IACrF,CAAC;IAED;;;;;;OAMG;IACI,WAAW,CAAC,OAAuB;QACtC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC;QAC/C,MAAM,GAAG,GAAG,IAAI,CAAC,wBAAwB,CAAC,MAAM,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC;QAEtE,OAAO,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CACxB,IAAI,CAAC,CAAC,CAAC,EACP,SAAS,CAAC,GAAG,EAAE;YACX,IAAI,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;gBACjC,OAAO,IAAI,CAAC,iBAAiB;qBACxB,GAAG,CAAC,GAAG,CAAC;qBACR,yBAAyB,EAAE;qBAC3B,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;aACtB;YAED,OAAO,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,CAAC,IAAI,CACvC,MAAM,CAAC,CAAC,gBAAgB,EAAE,EAAE;gBACxB,OAAO,IAAI,CAAC,wBAAwB,CAChC,gBAAgB,CAAC,MAAM,EACvB,gBAAgB,CAAC,OAAO,EACxB,gBAAgB,CAAC,SAAS,CAC7B,KAAK,GAAG,CAAC;YACd,CAAC,CAAC,EACF,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,EACf,IAAI,CAAC,CAAC,CAAC,CACV,CAAC;QACN,CAAC,CAAC,CACL,CAAC;IACN,CAAC;IAEO,KAAK,CAAC,OAAe,EAAE,GAAG,cAAqB;QACnD,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACnB,OAAO;SACV;QACD,OAAO,CAAC,GAAG,CAAC,YAAY,GAAG,OAAO,EAAE,GAAG,cAAc,CAAC,CAAC;IAC3D,CAAC;IAEO,IAAI,CAAC,OAAe;QACxB,OAAO,CAAC,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,CAAC;IACxC,CAAC;IAEO,iBAAiB;QACrB,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;QAEjC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC3B,IAAI,IAAI,CAAC,cAAc,EAAE;YACrB,IAAI,CAAC,IAAI,CAAC,iDAAiD,CAAC,CAAC;YAC7D,IAAI,CAAC,kBAAkB,EAAE,CAAC;SAC7B;IACL,CAAC;IAEO,kBAAkB;QACtB,IAAI,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;QAEpC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC5B,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;IAC9B,CAAC;IAEO,sBAAsB,CAAC,IAAgB;;QAC3C,IAAI,OAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,MAAM,0CAAE,WAAW,GAAG,OAAO,CAAC,SAAS,OAAM,CAAC,CAAC,EAAE;YACvD,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;YAC3B,IAAI,CAAC,WAAW,CAAC,qBAAqB,EAAE,IAAI,SAAS,CACjD;gBACI,OAAO,EAAE,IAAI,CAAC,IAAI;gBAClB,OAAO,EAAE;oBACL,OAAO,EAAE,IAAI,CAAC,MAAM;iBACvB;aACJ,CACJ,CAAC,CAAC;YACH,OAAO;SACV;QAED,IAAI,OAAA,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,MAAM,0CAAE,WAAW,GAAG,OAAO,CAAC,0BAA0B,OAAM,CAAC,CAAC,EAAE;YACxE,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;YAC3B,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,IAAI,SAAS,CAC7C;gBACI,OAAO,EAAE,IAAI,CAAC,IAAI;gBAClB,OAAO,EAAE;oBACL,OAAO,EAAE,IAAI,CAAC,MAAM;iBACvB;aACJ,CACJ,CAAC,CAAC;YACH,OAAO;SACV;QAED,IAAI,IAAI,CAAC,QAAQ,EAAE;YACf,OAAO;SACV;QAED,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;IAC/B,CAAC;IAEO,kBAAkB,CAAC,IAAe;QACtC,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;QAErC,IAAI,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAE;YAClC,IAAI,CAAC,IAAI,CAAC,gDAAgD,CAAC,CAAC;YAC5D,IAAI,CAAC,kBAAkB,EAAE,CAAC;SAC7B;IACL,CAAC;IAEO,qBAAqB,CAAC,IAAe;;QACzC,MAAM,YAAY,SAAG,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,OAAO,0CAAE,OAAO,CAAC;QAC5C,IAAI,CAAC,YAAY,EAAE;YACf,OAAO,KAAK,CAAC;SAChB;QAED,OAAO,YAAY,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CAAC;IAC3E,CAAC;IAEO,sBAAsB,CAAC,IAAS;QACpC,IAAI,CAAC,WAAW,CAAC,gBAAgB,EAAE,IAAI,CAAC,CAAC;IAC7C,CAAC;IAEO,WAAW,CAAC,MAAc,EAAE,IAAe;QAC/C,OAAO,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAC5B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAEO,kBAAkB;QACtB,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;QAC5B,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;IAC7B,CAAC;IAEO,mBAAmB;QACvB,KAAK,MAAM,gBAAgB,IAAI,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,EAAE;YAC5D,IAAI,CAAC,wBAAwB,CAAC,gBAAgB,CAAC,CAAC;SACnD;IACL,CAAC;IAEO,6BAA6B,CAAC,MAAc,EAAE,OAAe,EAAE,SAAiB;QACpF,MAAM,SAAS,GAAG,IAAI,CAAC,sBAAsB,CAAC,YAAY,EAAE,CAAC;QAC7D,MAAM,MAAM,GAAG,IAAI,CAAC,sBAAsB,CAAC,eAAe,EAAE,CAAC;QAC7D,OAAO,UAAU,MAAM,IAAI,SAAS,IAAI,MAAM,IAAI,OAAO,IAAI,SAAS,EAAE,CAAC;IAC7E,CAAC;IAEO,8BAA8B,CAAC,MAAc,EAAE,OAAe,EAAE,SAAiB;QACrF,MAAM,MAAM,GAAG,IAAI,CAAC,sBAAsB,CAAC,eAAe,EAAE,CAAC;QAC7D,OAAO,UAAU,MAAM,IAAI,MAAM,IAAI,OAAO,IAAI,SAAS,EAAE,CAAC;IAChE,CAAC;IAEO,wBAAwB,CAAC,MAAc,EAAE,OAAe,EAAE,SAAiB;QAC/E,OAAO,GAAG,MAAM,IAAI,OAAO,IAAI,SAAS,EAAE,CAAC;IAC/C,CAAC;IAEa,8BAA8B,CAAC,gBAAuC;;YAChF,IAAI,gBAAgB,CAAC,YAAY,EAAE,EAAE;gBACjC,OAAO;aACV;YAED,gBAAgB,CAAC,WAAW,EAAE,CAAC;YAE/B,MAAM,GAAG,GAAG,IAAI,CAAC,wBAAwB,CAAC,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,CAAC,SAAS,CAAC,CAAC;YACzH,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAEnC,MAAM,IAAI,CAAC,6BAA6B,EAAE,CAAC;QAC/C,CAAC;KAAA;IAEa,6BAA6B;;YACvC,IAAI,IAAI,CAAC,iBAAiB,EAAE,KAAK,CAAC,EAAE;gBAChC,IAAI,CAAC,KAAK,CAAC,4DAA4D,CAAC,CAAC;gBACzE,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;aAC3B;QACL,CAAC;KAAA;IAEO,iBAAiB;QACrB,IAAI,cAAc,GAAG,CAAC,CAAC;QAEvB,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE;YAC9C,cAAc,IAAI,gBAAgB,CAAC,iBAAiB,EAAE,CAAC;QAC3D,CAAC,CAAC,CAAC;QAEH,OAAO,cAAc,CAAC;IAC1B,CAAC;IAEO,uBAAuB,CAAI,WAAmB,EAAE,gBAAqC;QACzF,OAAO,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC,OAAY,EAAE,EAAE;YAC5D,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC;YAC/C,gBAAgB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,wBAAwB,CAAI,gBAAqC;QACrE,MAAM,wBAAwB,GAAG,IAAI,CAAC,6BAA6B,CAC/D,gBAAgB,CAAC,MAAM,EACvB,gBAAgB,CAAC,OAAO,EACxB,gBAAgB,CAAC,SAAS,CAC7B,CAAC;QACF,MAAM,2BAA2B,GAAG,IAAI,CAAC,8BAA8B,CACnE,gBAAgB,CAAC,MAAM,EACvB,gBAAgB,CAAC,OAAO,EACxB,gBAAgB,CAAC,SAAS,CAC7B,CAAC;QAEF,MAAM,0BAA0B,GAAG,IAAI,CAAC,uBAAuB,CAAC,wBAAwB,EAAE,gBAAgB,CAAC,CAAC;QAC5G,MAAM,6BAA6B,GAAG,IAAI,CAAC,uBAAuB,CAAC,2BAA2B,EAAE,gBAAgB,CAAC,CAAC;QAClH,gBAAgB,CAAC,SAAS,CAAC,0BAA0B,EAAE,6BAA6B,CAAC,CAAC;QACtF,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAC5C,CAAC;IAEO,kBAAkB;QACtB,OAAO,GAAG,IAAI,CAAC,sBAAsB,CAAC,eAAe,EAAE,eAAe,CAAC;IAC3E,CAAC;CACJ,CAAA;;YAzXwD,sBAAsB;;;AAdlE,gBAAgB;IAH5B,UAAU,CAAC;QACR,UAAU,EAAE,MAAM;KACrB,CAAC;GACW,gBAAgB,CAuY5B;SAvYY,gBAAgB","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { filter, finalize, map, switchMap, take } from 'rxjs/operators';\r\nimport { Client, FrameImpl, StompConfig, StompSubscription } from '@stomp/stompjs';\r\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\r\nconst SockJS = require('sockjs-client');\r\nimport { AsyncLock } from './async-lock';\r\nimport { UserInformationService } from './user-information.service';\r\nimport { PrimitiveManager } from './models';\r\nimport { OnEventOptions, PrimitiveEvent } from './protocols';\r\n\r\nconst RECONNECT_INTERVAL_MILLISECONDS = 3000;\r\nconst CONNECTION_TIMEOUT_MILLISECONDS = 5000;\r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class WebsocketService {\r\n    private readonly connected$ = new BehaviorSubject<boolean>(false);\r\n    private readonly disconnected$ = new Subject<void>();\r\n    private readonly reconnected$ = new Subject<void>();\r\n    private readonly error$ = new Subject<FrameImpl>();\r\n    private readonly subscribed$ = new Subject<PrimitiveManager<any>>();\r\n\r\n    private readonly primitiveManagers: Map<string, PrimitiveManager<any>> = new Map<string, PrimitiveManager<any>>();\r\n    private readonly connectionLock = new AsyncLock();\r\n\r\n    private stompClient: Client;\r\n    private debugEnable = false;\r\n    private lostConnection = false;\r\n\r\n    constructor(private readonly userInformationService: UserInformationService) {\r\n    }\r\n\r\n    /**\r\n     * Enables stompjs debug logs and additional info\r\n     */\r\n    public enableDebugLogs() {\r\n        this.debugEnable = true;\r\n    }\r\n\r\n    /**\r\n     * Manually starts the connection\r\n     */\r\n    public async connect() {\r\n        await this.connectionLock.acquire();\r\n\r\n        try {\r\n            if (this.isConnected() || this.isConnecting()) {\r\n                return;\r\n            }\r\n            this.lostConnection = false;\r\n\r\n            const stompConfig: StompConfig = {\r\n                webSocketFactory: () => {\r\n                    return new SockJS(\r\n                        this.getSubscriptionUrl(),\r\n                        null,\r\n                        {\r\n                            timeout: CONNECTION_TIMEOUT_MILLISECONDS\r\n                        }\r\n                    );\r\n                },\r\n                reconnectDelay: RECONNECT_INTERVAL_MILLISECONDS,\r\n                debug: this.debug.bind(this),\r\n                onConnect: this.handleOnConnected.bind(this),\r\n                onDisconnect: this.handleOnDisconnect.bind(this),\r\n                onWebSocketClose: this.handleOnWebSocketClose.bind(this),\r\n                onStompError: this.handleOnStompError.bind(this),\r\n                onWebSocketError: this.handleOnWebSocketError.bind(this)\r\n            };\r\n\r\n            this.debug('Connecting the Webscoket');\r\n\r\n            this.stompClient = new Client(stompConfig);\r\n            this.stompClient.activate();\r\n        } finally {\r\n            await this.connectionLock.release();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Manually disconnect the websocket. The reconnect loop will be stopped.\r\n     */\r\n    public async disconnect(): Promise<void> {\r\n        if (!this.isConnected()) {\r\n            return;\r\n        }\r\n\r\n        await this.connectionLock.acquire();\r\n        try {\r\n            for (const primitiveManager of this.primitiveManagers.values()) {\r\n                primitiveManager.unsubscribe();\r\n            }\r\n\r\n            this.primitiveManagers.clear();\r\n            this.connected$.next(false);\r\n\r\n            if (this.stompClient) {\r\n                await this.stompClient.deactivate();\r\n            }\r\n        } finally {\r\n            await this.connectionLock.release();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Check if the websocket is connected\r\n     * @return `boolean` representing if the websocket is connected\r\n     */\r\n    public isConnected(): boolean {\r\n        if (!this.stompClient) {\r\n            return false;\r\n        }\r\n\r\n        return this.stompClient.connected;\r\n    }\r\n\r\n    /**\r\n     * Check if the websocket is tring to connect\r\n     * @return `boolean` representing if the websocket status\r\n     */\r\n    public isConnecting(): boolean {\r\n        if (!this.stompClient) {\r\n            return false;\r\n        }\r\n\r\n        return !this.stompClient.connected && this.stompClient.active;\r\n    }\r\n\r\n    /**\r\n     * Event responsable to emit an event when the connection is established.\r\n     * Do not forget to unsubscribe the observable when you don't need it anymore.\r\n     * @return `Observable<boolean>`\r\n     */\r\n    public onConnect(): Observable<boolean> {\r\n        return this.connected$.asObservable()\r\n            .pipe(filter(p => p === true));\r\n    }\r\n\r\n    /**\r\n     * Event responsable to emit an event when the connection is closed.\r\n     * Do not forget to unsubscribe the observable when you don't need it anymore.\r\n     * @return `Observable<void>`\r\n     */\r\n    public onDisconnect(): Observable<void> {\r\n        return this.disconnected$.asObservable();\r\n    }\r\n\r\n    /**\r\n     * Event responsable to emit an event when the connection is reestablished.\r\n     * Do not forget to unsubscribe the observable when you don't need it anymore.\r\n     * @return `Observable<void>`\r\n     */\r\n    public onReconnect(): Observable<void> {\r\n        return this.reconnected$.asObservable();\r\n    }\r\n\r\n    /**\r\n     * Event responsable to emit an event when an error ocurred.\r\n     * Do not forget to unsubscribe the observable when you don't need it anymore.\r\n     * @return `Observable<FrameImpl>`\r\n     */\r\n    public onError(): Observable<FrameImpl> {\r\n        return this.error$.asObservable();\r\n    }\r\n\r\n    /**\r\n     * Event responsible to emit an event when a primitive is called.\r\n     * Do not forget to unsubscribe the observable when you don't need it anymore.\r\n     * @typeParam `<T>` Object type that will be used in the observable for the `data` property.\r\n     * @param {OnEventOptions} options Configurations for the event.\r\n     * @return `Observable<PrimitiveEvent<T>>` Observable that emits an event when the service calls the primitive.\r\n     */\r\n    public onEvent<T>(options: OnEventOptions): Observable<PrimitiveEvent<T>> {\r\n        const { domain, service, primitive } = options;\r\n        const key = this.buildPrimitiveManagerKey(domain, service, primitive);\r\n\r\n        if (this.primitiveManagers.has(key)) {\r\n            return this.primitiveManagers.get(key).getEventObservable();\r\n        }\r\n\r\n        const primitiveManager = new PrimitiveManager<T>(domain, service, primitive);\r\n        this.primitiveManagers.set(key, primitiveManager);\r\n\r\n        this.connect().then(() => {\r\n            this.onConnect()\r\n                .pipe(take(1))\r\n                .subscribe(() => {\r\n                    this.createStompSubscriptions(primitiveManager);\r\n                });\r\n        });\r\n\r\n        return primitiveManager\r\n            .getEventObservable()\r\n            .pipe(finalize(() => this.unsubscribePrimitiveOnFinalize(primitiveManager)));\r\n    }\r\n\r\n    /**\r\n     * Event responsible to emit an event when a subscription is created for the primitive.\r\n     * Do not forget to unsubscribe the observable when you don't need it anymore.\r\n     * @param {OnEventOptions} options Configurations for the event.\r\n     * Observable responsável por emitir uma notificação após o subscribe do evento pela primeira vez.\r\n     * @return `Observable<boolean>` Observable that emits an event when the service calls the primitive.\r\n     */\r\n    public onSubscribe(options: OnEventOptions): Observable<boolean> {\r\n        const { domain, service, primitive } = options;\r\n        const key = this.buildPrimitiveManagerKey(domain, service, primitive);\r\n\r\n        return this.onConnect().pipe(\r\n            take(1),\r\n            switchMap(() => {\r\n                if (this.primitiveManagers.has(key)) {\r\n                    return this.primitiveManagers\r\n                        .get(key)\r\n                        .getSubscriptionObservable()\r\n                        .pipe(take(1));\r\n                }\r\n\r\n                return this.subscribed$.asObservable().pipe(\r\n                    filter((primitiveManager) => {\r\n                        return this.buildPrimitiveManagerKey(\r\n                            primitiveManager.domain,\r\n                            primitiveManager.service,\r\n                            primitiveManager.primitive\r\n                        ) === key;\r\n                    }),\r\n                    map(() => true),\r\n                    take(1)\r\n                );\r\n            })\r\n        );\r\n    }\r\n\r\n    private debug(message: string, ...optionalParams: any[]) {\r\n        if (!this.debugEnable) {\r\n            return;\r\n        }\r\n        console.log('WS debug: ' + message, ...optionalParams);\r\n    }\r\n\r\n    private info(message: string) {\r\n        console.info('WS info: ' + message);\r\n    }\r\n\r\n    private handleOnConnected() {\r\n        this.info('Webscoket connected');\r\n\r\n        this.connected$.next(true);\r\n        if (this.lostConnection) {\r\n            this.info('Webscoket reconnected, recriating subscriptions');\r\n            this.handleReconnection();\r\n        }\r\n    }\r\n\r\n    private handleOnDisconnect() {\r\n        this.info('Webscoket disconnected');\r\n\r\n        this.connected$.next(false);\r\n        this.disconnected$.next();\r\n    }\r\n\r\n    private handleOnWebSocketClose(data: CloseEvent) {\r\n        if (data?.reason?.toLowerCase().indexOf(\"go away\") !== -1) {\r\n            this.lostConnection = true;\r\n            this.handleError('AuthenticationError', new FrameImpl(\r\n                {\r\n                    command: data.type,\r\n                    headers: {\r\n                        message: data.reason\r\n                    }\r\n                }\r\n            ));\r\n            return;\r\n        }\r\n\r\n        if (data?.reason?.toLowerCase().indexOf(\"cannot connect to server\") !== -1) {\r\n            this.lostConnection = true;\r\n            this.handleError('ConnectionError', new FrameImpl(\r\n                {\r\n                    command: data.type,\r\n                    headers: {\r\n                        message: data.reason\r\n                    }\r\n                }\r\n            ));\r\n            return;\r\n        }\r\n\r\n        if (data.wasClean) {\r\n            return;\r\n        }\r\n\r\n        this.lostConnection = true;\r\n    }\r\n\r\n    private handleOnStompError(data: FrameImpl) {\r\n        this.handleError('StompError', data);\r\n\r\n        if (this.isAuthenticationError(data)) {\r\n            this.info('Authentication error, recriating subscriptions');\r\n            this.handleReconnection();\r\n        }\r\n    }\r\n\r\n    private isAuthenticationError(data: FrameImpl) {\r\n        const errorMessage = data?.headers?.message;\r\n        if (!errorMessage) {\r\n            return false;\r\n        }\r\n\r\n        return errorMessage.toLowerCase().indexOf('forbiddenexception') !== -1;\r\n    }\r\n\r\n    private handleOnWebSocketError(data: any) {\r\n        this.handleError('WebSocketError', data);\r\n    }\r\n\r\n    private handleError(origin: string, data: FrameImpl) {\r\n        console.error(origin, data);\r\n        this.error$.next(data);\r\n    }\r\n\r\n    private handleReconnection() {\r\n        this.lostConnection = false;\r\n        this.reconnectPrimitives();\r\n        this.reconnected$.next();\r\n    }\r\n\r\n    private reconnectPrimitives(): void {\r\n        for (const primitiveManager of this.primitiveManagers.values()) {\r\n            this.createStompSubscriptions(primitiveManager);\r\n        }\r\n    }\r\n\r\n    private buildSubscriptionUrlWithToken(domain: string, service: string, primitive: string): string {\r\n        const authToken = this.userInformationService.getAuthToken();\r\n        const tenant = this.userInformationService.getTenantDomain();\r\n        return `/topic/${tenant}/${authToken}/${domain}/${service}/${primitive}`;\r\n    }\r\n\r\n    private getSubscriptionUrlWithoutToken(domain: string, service: string, primitive: string): string {\r\n        const tenant = this.userInformationService.getTenantDomain();\r\n        return `/topic/${tenant}/${domain}/${service}/${primitive}`;\r\n    }\r\n\r\n    private buildPrimitiveManagerKey(domain: string, service: string, primitive: string): string {\r\n        return `${domain}/${service}/${primitive}`;\r\n    }\r\n\r\n    private async unsubscribePrimitiveOnFinalize(primitiveManager: PrimitiveManager<any>) {\r\n        if (primitiveManager.hasObservers()) {\r\n            return;\r\n        }\r\n\r\n        primitiveManager.unsubscribe();\r\n\r\n        const key = this.buildPrimitiveManagerKey(primitiveManager.domain, primitiveManager.service, primitiveManager.primitive);\r\n        this.primitiveManagers.delete(key);\r\n\r\n        await this.disconnectIfNoMoreObservables();\r\n    }\r\n\r\n    private async disconnectIfNoMoreObservables() {\r\n        if (this.getObserversCount() === 0) {\r\n            this.debug('Manually disconnecting because there are no more observers');\r\n            await this.disconnect();\r\n        }\r\n    }\r\n\r\n    private getObserversCount(): number {\r\n        let observersCount = 0;\r\n\r\n        this.primitiveManagers.forEach(primitiveManager => {\r\n            observersCount += primitiveManager.getObserversCount();\r\n        });\r\n\r\n        return observersCount;\r\n    }\r\n\r\n    private createStompSubscription<T>(destination: string, primitiveManager: PrimitiveManager<T>): StompSubscription {\r\n        return this.stompClient.subscribe(destination, (message: any) => {\r\n            const event = JSON.parse(message.body || '{}');\r\n            primitiveManager.fireEvent(event);\r\n        });\r\n    }\r\n\r\n    private createStompSubscriptions<T>(primitiveManager: PrimitiveManager<T>): void {\r\n        const subscriptionUrlWithToken = this.buildSubscriptionUrlWithToken(\r\n            primitiveManager.domain,\r\n            primitiveManager.service,\r\n            primitiveManager.primitive\r\n        );\r\n        const subscriptionUrlWithoutToken = this.getSubscriptionUrlWithoutToken(\r\n            primitiveManager.domain,\r\n            primitiveManager.service,\r\n            primitiveManager.primitive\r\n        );\r\n\r\n        const stompSubscriptionWithToken = this.createStompSubscription(subscriptionUrlWithToken, primitiveManager);\r\n        const stompSubscriptionWithoutToken = this.createStompSubscription(subscriptionUrlWithoutToken, primitiveManager);\r\n        primitiveManager.subscribe(stompSubscriptionWithToken, stompSubscriptionWithoutToken);\r\n        this.subscribed$.next(primitiveManager);\r\n    }\r\n\r\n    private getSubscriptionUrl() {\r\n        return `${this.userInformationService.getWebSocketUrl()}/subscription`;\r\n    }\r\n}\r\n"]}

package/esm5/agro-angular-components.module.js

@@ -0,0 +1,26 @@
+import { __decorate } from "tslib";
+import { NgModule, InjectionToken } from "@angular/core";
+export var HostProjectConfigsInjectionToken = new InjectionToken("hostProjectConfigs");
+var AgroAngularComponentsModule = /** @class */ (function () {
+    function AgroAngularComponentsModule() {
+    }
+    AgroAngularComponentsModule_1 = AgroAngularComponentsModule;
+    AgroAngularComponentsModule.forRoot = function (config) {
+        return {
+            ngModule: AgroAngularComponentsModule_1,
+            providers: [
+                {
+                    provide: HostProjectConfigsInjectionToken,
+                    useValue: config
+                }
+            ]
+        };
+    };
+    var AgroAngularComponentsModule_1;
+    AgroAngularComponentsModule = AgroAngularComponentsModule_1 = __decorate([
+        NgModule({})
+    ], AgroAngularComponentsModule);
+    return AgroAngularComponentsModule;
+}());
+export { AgroAngularComponentsModule };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdyby1hbmd1bGFyLWNvbXBvbmVudHMubW9kdWxlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQHNlbmlvci1hZ3JvbmVnb2Npby9hbmd1bGFyLWNvbXBvbmVudHMvIiwic291cmNlcyI6WyJhZ3JvLWFuZ3VsYXItY29tcG9uZW50cy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFFSCxRQUFRLEVBQ1IsY0FBYyxFQUNqQixNQUFNLGVBQWUsQ0FBQztBQUV2QixNQUFNLENBQUMsSUFBTSxnQ0FBZ0MsR0FBRyxJQUFJLGNBQWMsQ0FBcUIsb0JBQW9CLENBQUMsQ0FBQztBQVM3RztJQUFBO0lBWUEsQ0FBQztvQ0FaWSwyQkFBMkI7SUFDN0IsbUNBQU8sR0FBZCxVQUFlLE1BQTBCO1FBQ3JDLE9BQU87WUFDSCxRQUFRLEVBQUUsNkJBQTJCO1lBQ3JDLFNBQVMsRUFBRTtnQkFDUDtvQkFDSSxPQUFPLEVBQUUsZ0NBQWdDO29CQUN6QyxRQUFRLEVBQUUsTUFBTTtpQkFDbkI7YUFDSjtTQUNKLENBQUM7SUFDTixDQUFDOztJQVhRLDJCQUEyQjtRQUZ2QyxRQUFRLENBQUMsRUFDVCxDQUFDO09BQ1csMkJBQTJCLENBWXZDO0lBQUQsa0NBQUM7Q0FBQSxBQVpELElBWUM7U0FaWSwyQkFBMkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xyXG4gICAgTW9kdWxlV2l0aFByb3ZpZGVycyxcclxuICAgIE5nTW9kdWxlLFxyXG4gICAgSW5qZWN0aW9uVG9rZW5cclxufSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5cclxuZXhwb3J0IGNvbnN0IEhvc3RQcm9qZWN0Q29uZmlnc0luamVjdGlvblRva2VuID0gbmV3IEluamVjdGlvblRva2VuPEhvc3RQcm9qZWN0Q29uZmlncz4oXCJob3N0UHJvamVjdENvbmZpZ3NcIik7XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIEhvc3RQcm9qZWN0Q29uZmlncyB7XHJcbiAgICBkb21haW46IHN0cmluZztcclxuICAgIHNlcnZpY2U6IHN0cmluZztcclxufVxyXG5cclxuQE5nTW9kdWxlKHtcclxufSlcclxuZXhwb3J0IGNsYXNzIEFncm9Bbmd1bGFyQ29tcG9uZW50c01vZHVsZSB7XHJcbiAgICBzdGF0aWMgZm9yUm9vdChjb25maWc6IEhvc3RQcm9qZWN0Q29uZmlncyk6IE1vZHVsZVdpdGhQcm92aWRlcnM8QWdyb0FuZ3VsYXJDb21wb25lbnRzTW9kdWxlPiB7XHJcbiAgICAgICAgcmV0dXJuIHtcclxuICAgICAgICAgICAgbmdNb2R1bGU6IEFncm9Bbmd1bGFyQ29tcG9uZW50c01vZHVsZSxcclxuICAgICAgICAgICAgcHJvdmlkZXJzOiBbXHJcbiAgICAgICAgICAgICAgICB7XHJcbiAgICAgICAgICAgICAgICAgICAgcHJvdmlkZTogSG9zdFByb2plY3RDb25maWdzSW5qZWN0aW9uVG9rZW4sXHJcbiAgICAgICAgICAgICAgICAgICAgdXNlVmFsdWU6IGNvbmZpZ1xyXG4gICAgICAgICAgICAgICAgfVxyXG4gICAgICAgICAgICBdXHJcbiAgICAgICAgfTtcclxuICAgIH1cclxufVxyXG4iXX0=

package/esm5/common/agro-array-utils.class.js

@@ -0,0 +1,72 @@
+import { __values } from "tslib";
+/**
+ * Classe com funções úteis para Arrays.
+ */
+var AgroArrayUtils = /** @class */ (function () {
+    function AgroArrayUtils() {
+    }
+    /**
+     * Verifica se o valor informado é um array.
+     */
+    AgroArrayUtils.isArray = function (value) {
+        return Array.isArray(value);
+    };
+    /**
+     * Remove um item de um array.
+     * @param array Array de onde o item será removido.
+     * @param item Item a ser removido.
+     */
+    AgroArrayUtils.removeItem = function (array, item) {
+        var index = array.indexOf(item);
+        if (index !== -1) {
+            array.splice(index, 1);
+        }
+    };
+    /**
+     * Remove um item de um array por índice.
+     * @param array Array de onde o item será removido.
+     * @param index Índice do item a ser removido.
+     */
+    AgroArrayUtils.removeItemByIndex = function (array, index) {
+        array.splice(index, 1);
+    };
+    /**
+     * Remove todos os itens de um array.
+     * @param array Array de onde os itens serão removidos.
+     */
+    AgroArrayUtils.removeAllItems = function (array) {
+        array.splice(0, array.length);
+    };
+    /**
+     * Verifica se um array é vazio.
+     * @param array Array a ser verificado.
+     */
+    AgroArrayUtils.isEmpty = function (array) {
+        return AgroArrayUtils.isArray(array) && array.length === 0;
+    };
+    /**
+     * Localiza um item em um array de objetos de acordo com a propriedade e valor informados.
+     */
+    AgroArrayUtils.findItemByProperty = function (array, property, value) {
+        var e_1, _a;
+        try {
+            for (var array_1 = __values(array), array_1_1 = array_1.next(); !array_1_1.done; array_1_1 = array_1.next()) {
+                var item = array_1_1.value;
+                if (item[property] === value) {
+                    return item;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (array_1_1 && !array_1_1.done && (_a = array_1.return)) _a.call(array_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return null;
+    };
+    return AgroArrayUtils;
+}());
+export { AgroArrayUtils };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/common/agro-cookie-utils.class.js

@@ -0,0 +1,38 @@
+import { __read } from "tslib";
+export { AgroCookieUtils as ACU, AgroCookieUtils as CookieUtils };
+var AgroCookieUtils = /** @class */ (function () {
+    function AgroCookieUtils() {
+    }
+    AgroCookieUtils.getCookie = function (name, parseURIValue) {
+        if (parseURIValue === void 0) { parseURIValue = false; }
+        var cookieValue = document.cookie.split(';')
+            .map(function (cookie) { return cookie.trim(); })
+            .find(function (cookie) { return cookie.startsWith(name); });
+        var result = cookieValue === null || cookieValue === void 0 ? void 0 : cookieValue.split('=')[1];
+        if (parseURIValue && result) {
+            result = decodeURIComponent(result);
+        }
+        return result;
+    };
+    AgroCookieUtils.parseCookieToObject = function (cookieString, parseURIString) {
+        if (parseURIString === void 0) { parseURIString = false; }
+        var cookieObject = {};
+        if (parseURIString) {
+            cookieString = decodeURIComponent(cookieString);
+        }
+        cookieString.split(';').forEach(function (cookie) {
+            var _a = __read(cookie.split('=').map(function (c) { return c.trim(); }), 2), key = _a[0], value = _a[1];
+            cookieObject[key] = value;
+        });
+        return cookieObject;
+    };
+    AgroCookieUtils.prototype.setCookie = function (name, value, days) {
+        var date = new Date();
+        date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+        var expires = 'expires=' + date.toUTCString();
+        document.cookie = name + '=' + value + ';' + expires + ';path=/';
+    };
+    return AgroCookieUtils;
+}());
+export { AgroCookieUtils };
+//# sourceMappingURL=data:application/json;base64,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