vc-error-handlers 0.1.97 → 0.1.99

package/esm2022/lib/shared/constants/api-config.constants.mjs

@@ -0,0 +1,240 @@
+export const PAGE_LEVEL_API_CONFIG = [
+    {
+        method: '',
+        path: '',
+        query: null,
+        body: null,
+        pageCodes: [''],
+    },
+];
+export const COMPONENT_LEVEL_API_CONFIG = [
+    {
+        method: 'GET',
+        path: '/organization/?mode=organisationUsersList',
+        query: { type: 'active' },
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/organization/?mode=organisationUsersList',
+        query: { type: 'power_users' },
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/organization/?mode=organisationUsersList',
+        query: { type: 'light_users' },
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/organization/?mode=organisationUsersList',
+        query: { type: 'inactive' },
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/organization/?mode=organisationUsersList',
+        query: { type: 'power_users_small' },
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/Global-Dashboard/ManageDashboards',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/Global-Dashboard/MyDashboard',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/grc_object/?mode=grc/getGRCList',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/compliance/?mode=responsibilityCenterTree',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/organization/?mode=rcholidaylist',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/organization/?mode=roles/getRoles',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/organization/?mode=groupsList',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'POST',
+        path: '/compliance_post/?mode=rcProfile',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'POST',
+        path: '/organization_post/?mode=userProfile',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/organization/?mode=roles/roleById',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/organization/?mode=groupDetails',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'POST',
+        path: '/compliance_post?mode=report/list',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/organization/?mode=memberholidaylist',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/grc_object/?mode=activity/activityLogList',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/grc_object/?mode=activity/viewList',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/program/categoriesList?owner_list=1',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'POST',
+        path: '/risk/?mode=category/list',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'POST',
+        path: 'memberDetailsbyIds',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/organization?mode=signatureDetails',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/program/responsibilityList',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/program/getLinkedPolicies',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'POST',
+        path: 'risk/list',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/program/assignee',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/program/evidence/getEvidences/b-cycle-header',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/program/activity-logs',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/program/activity-logs-views',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'POST',
+        path: '/Assessment/?mode=category/list',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'POST',
+        path: '/Assessment/?mode=assessment/list',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/Assessment/?mode=assessment/fetchQuestionsByAssessmentId',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'POST',
+        path: '/Assessment/?mode=assessment/responseSummary',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/Assessment/?mode=assessment/logs',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'GET',
+        path: '/program/subCategories',
+        query: null,
+        body: null,
+    },
+    {
+        method: 'POST',
+        path: '/Assessment/?mode=assessment/getAssessmentById',
+        query: null,
+        body: null,
+    },
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-config.constants.js","sourceRoot":"","sources":["../../../../../../projects/vc-error-handlers/src/lib/shared/constants/api-config.constants.ts"],"names":[],"mappings":"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","sourcesContent":["export const PAGE_LEVEL_API_CONFIG = [\r\n  {\r\n    method: '',\r\n    path: '',\r\n    query: null,\r\n    body: null,\r\n    pageCodes: [''],\r\n  },\r\n];\r\n\r\nexport const COMPONENT_LEVEL_API_CONFIG = [\r\n  {\r\n    method: 'GET',\r\n    path: '/organization/?mode=organisationUsersList',\r\n    query: { type: 'active' },\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/organization/?mode=organisationUsersList',\r\n    query: { type: 'power_users' },\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/organization/?mode=organisationUsersList',\r\n    query: { type: 'light_users' },\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/organization/?mode=organisationUsersList',\r\n    query: { type: 'inactive' },\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/organization/?mode=organisationUsersList',\r\n    query: { type: 'power_users_small' },\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/Global-Dashboard/ManageDashboards',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/Global-Dashboard/MyDashboard',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/grc_object/?mode=grc/getGRCList',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/compliance/?mode=responsibilityCenterTree',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/organization/?mode=rcholidaylist',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/organization/?mode=roles/getRoles',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/organization/?mode=groupsList',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'POST',\r\n    path: '/compliance_post/?mode=rcProfile',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'POST',\r\n    path: '/organization_post/?mode=userProfile',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/organization/?mode=roles/roleById',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/organization/?mode=groupDetails',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'POST',\r\n    path: '/compliance_post?mode=report/list',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/organization/?mode=memberholidaylist',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/grc_object/?mode=activity/activityLogList',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/grc_object/?mode=activity/viewList',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/program/categoriesList?owner_list=1',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'POST',\r\n    path: '/risk/?mode=category/list',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'POST',\r\n    path: 'memberDetailsbyIds',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/organization?mode=signatureDetails',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/program/responsibilityList',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/program/getLinkedPolicies',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'POST',\r\n    path: 'risk/list',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/program/assignee',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/program/evidence/getEvidences/b-cycle-header',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/program/activity-logs',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/program/activity-logs-views',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'POST',\r\n    path: '/Assessment/?mode=category/list',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'POST',\r\n    path: '/Assessment/?mode=assessment/list',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/Assessment/?mode=assessment/fetchQuestionsByAssessmentId',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'POST',\r\n    path: '/Assessment/?mode=assessment/responseSummary',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/Assessment/?mode=assessment/logs',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'GET',\r\n    path: '/program/subCategories',\r\n    query: null,\r\n    body: null,\r\n  },\r\n  {\r\n    method: 'POST',\r\n    path: '/Assessment/?mode=assessment/getAssessmentById',\r\n    query: null,\r\n    body: null,\r\n  },\r\n];\r\n"]}

package/esm2022/lib/shared/constants/error-handling.constants.mjs

@@ -0,0 +1,63 @@
+export const VCOMPLY_LOGO_URL = 'https://cdn.v-comply.com/logo/prod/v-logo.svg';
+export const API_TIMEOUT_TIME = 1000 * 15;
+export const ORGANISATION_NAME = 'VCOMPLY TECHNOLOGIES, INC.';
+export const ERROR_FEATURE_FLAG = 'ff_error_handling';
+export const ERROR_CONFIG = {
+    PAGE_NOT_FOUND: {
+        imageUrl: 'https://cdn.v-comply.com/application/images/Error-page-illustration.svg',
+        title: 'Oops!',
+        description: "The page you're looking for doesn't exist.",
+        details: 'Please check the URL or return to the homepage.',
+        buttonText: 'GO TO DASHBOARD',
+    },
+    UNAUTHORIZED: {
+        imageUrl: 'https://cdn.v-comply.com/application/images/Error-page-illustration.svg',
+        title: 'Oops!',
+        description: "You don't have permission to access this page.",
+        details: 'If you believe this is an error, please contact',
+        email: 'help@v-comply.com',
+        support: 'for support',
+        buttonText: 'CONTACT SUPPORT',
+        mail: 'mailto:help@v-comply.com',
+    },
+    SESSION_EXPIRED: {
+        heading: 'Session Expired!',
+        description: 'Your session has expired. Please log in again to continue using the app.',
+        buttonText: 'LOGIN',
+    },
+    CHUNK_UNAVAILABLE: {
+        heading: 'Oops!',
+        description: 'Something went wrong. Please refresh the page or try again later.',
+        buttonText: 'REFRESH',
+    },
+    SERVER_ERROR: {
+        imageUrl: 'https://cdn.v-comply.com/application/images/Error-page-illustration.svg',
+        title: 'Oops!',
+        description: 'We are unable to load the data.',
+        details: 'Please refresh this page or try again later.',
+        buttonText: 'REFRESH',
+        snackBarMessage: `Oops! Something went wrong. Please try again later.`,
+    },
+    COMPONENT_LEVEL_SERVER_ERROR: {
+        imageUrl: 'https://cdn.v-comply.com/application/images/sad-emoji-icon.svg',
+        title: 'Oops!',
+        description: 'We are unable to load the data.',
+        details: 'Please refresh this section or try again later.',
+        buttonText: 'RETRY',
+    },
+    NETWORK_UNAVAILABLE: {
+        offlineMessage: "You're currently offline. Please check your internet connection and try again.",
+    },
+};
+export const REDIRECTION_URL = {
+    compliance_dashboard: '/global-dashboard/compliance_dashboard',
+};
+export const MODAL_ERROR_TYPES = {
+    CHUNK_NOT_FOUND: 'chunk_not_found',
+    SESSION_EXPIRED: 'session_expired',
+};
+export const ALT_IMAGE_TEXT = {
+    ERROR_IMAGE: 'Error Image',
+    VCOMPLY_LOGO: 'VComply',
+};
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/shared/errorhandler/chunk-error.handler.mjs

@@ -1,18 +1,18 @@
-import { Injectable } from '@angular/core';
-import * as i0 from "@angular/core";
-export class GlobalErrorHandler {
-    handleError(error) {
-        const chunkFailedMessage = /Loading chunk [\d]+ failed/;
-        if (chunkFailedMessage.test(error.message) &&
-            confirm(`A new version is available. Please press "OK" to refresh the page.`)) {
-            window.location.reload();
-        }
-        console.error(error);
-    }
-}
-GlobalErrorHandler.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: GlobalErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-GlobalErrorHandler.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: GlobalErrorHandler });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.1", ngImport: i0, type: GlobalErrorHandler, decorators: [{
-            type: Injectable
-        }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2h1bmstZXJyb3IuaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZjLWVycm9yLWhhbmRsZXJzL3NyYy9saWIvc2hhcmVkL2Vycm9yaGFuZGxlci9jaHVuay1lcnJvci5oYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBZ0IsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUd6RCxNQUFNLE9BQU8sa0JBQWtCO0lBQzdCLFdBQVcsQ0FBQyxLQUFVO1FBQ3BCLE1BQU0sa0JBQWtCLEdBQUcsNEJBQTRCLENBQUM7UUFFeEQsSUFDRSxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQztZQUN0QyxPQUFPLENBQ0wsb0VBQW9FLENBQ3JFLEVBQ0Q7WUFDQSxNQUFNLENBQUMsUUFBUSxDQUFDLE1BQU0sRUFBRSxDQUFDO1NBQzFCO1FBQ0QsT0FBTyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUN2QixDQUFDOzsrR0FiVSxrQkFBa0I7bUhBQWxCLGtCQUFrQjsyRkFBbEIsa0JBQWtCO2tCQUQ5QixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRXJyb3JIYW5kbGVyLCBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG5ASW5qZWN0YWJsZSgpXHJcbmV4cG9ydCBjbGFzcyBHbG9iYWxFcnJvckhhbmRsZXIgaW1wbGVtZW50cyBFcnJvckhhbmRsZXIge1xyXG4gIGhhbmRsZUVycm9yKGVycm9yOiBhbnkpOiB2b2lkIHtcclxuICAgIGNvbnN0IGNodW5rRmFpbGVkTWVzc2FnZSA9IC9Mb2FkaW5nIGNodW5rIFtcXGRdKyBmYWlsZWQvO1xyXG5cclxuICAgIGlmIChcclxuICAgICAgY2h1bmtGYWlsZWRNZXNzYWdlLnRlc3QoZXJyb3IubWVzc2FnZSkgJiZcclxuICAgICAgY29uZmlybShcclxuICAgICAgICBgQSBuZXcgdmVyc2lvbiBpcyBhdmFpbGFibGUuIFBsZWFzZSBwcmVzcyBcIk9LXCIgdG8gcmVmcmVzaCB0aGUgcGFnZS5gXHJcbiAgICAgIClcclxuICAgICkge1xyXG4gICAgICB3aW5kb3cubG9jYXRpb24ucmVsb2FkKCk7XHJcbiAgICB9XHJcbiAgICBjb25zb2xlLmVycm9yKGVycm9yKTtcclxuICB9XHJcbn1cclxuIl19
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class GlobalErrorHandler {
+    handleError(error) {
+        const chunkFailedMessage = /Loading chunk [\d]+ failed/;
+        if (chunkFailedMessage.test(error.message) &&
+            confirm(`A new version is available. Please press "OK" to refresh the page.`)) {
+            window.location.reload();
+        }
+        console.error(error);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GlobalErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GlobalErrorHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GlobalErrorHandler, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2h1bmstZXJyb3IuaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZjLWVycm9yLWhhbmRsZXJzL3NyYy9saWIvc2hhcmVkL2Vycm9yaGFuZGxlci9jaHVuay1lcnJvci5oYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBZ0IsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUd6RCxNQUFNLE9BQU8sa0JBQWtCO0lBQzdCLFdBQVcsQ0FBQyxLQUFVO1FBQ3BCLE1BQU0sa0JBQWtCLEdBQUcsNEJBQTRCLENBQUM7UUFFeEQsSUFDRSxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQztZQUN0QyxPQUFPLENBQ0wsb0VBQW9FLENBQ3JFLEVBQ0Q7WUFDQSxNQUFNLENBQUMsUUFBUSxDQUFDLE1BQU0sRUFBRSxDQUFDO1NBQzFCO1FBQ0QsT0FBTyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUN2QixDQUFDOytHQWJVLGtCQUFrQjttSEFBbEIsa0JBQWtCOzs0RkFBbEIsa0JBQWtCO2tCQUQ5QixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRXJyb3JIYW5kbGVyLCBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG5ASW5qZWN0YWJsZSgpXHJcbmV4cG9ydCBjbGFzcyBHbG9iYWxFcnJvckhhbmRsZXIgaW1wbGVtZW50cyBFcnJvckhhbmRsZXIge1xyXG4gIGhhbmRsZUVycm9yKGVycm9yOiBhbnkpOiB2b2lkIHtcclxuICAgIGNvbnN0IGNodW5rRmFpbGVkTWVzc2FnZSA9IC9Mb2FkaW5nIGNodW5rIFtcXGRdKyBmYWlsZWQvO1xyXG5cclxuICAgIGlmIChcclxuICAgICAgY2h1bmtGYWlsZWRNZXNzYWdlLnRlc3QoZXJyb3IubWVzc2FnZSkgJiZcclxuICAgICAgY29uZmlybShcclxuICAgICAgICBgQSBuZXcgdmVyc2lvbiBpcyBhdmFpbGFibGUuIFBsZWFzZSBwcmVzcyBcIk9LXCIgdG8gcmVmcmVzaCB0aGUgcGFnZS5gXHJcbiAgICAgIClcclxuICAgICkge1xyXG4gICAgICB3aW5kb3cubG9jYXRpb24ucmVsb2FkKCk7XHJcbiAgICB9XHJcbiAgICBjb25zb2xlLmVycm9yKGVycm9yKTtcclxuICB9XHJcbn1cclxuIl19

package/esm2022/lib/shared/errorhandler/sentry-error.handler.mjs

@@ -0,0 +1,47 @@
+import { Injectable, Optional } from '@angular/core';
+import * as Sentry from '@sentry/angular-ivy';
+import * as i0 from "@angular/core";
+import * as i1 from "@vcomply/authorizer";
+import * as i2 from "../services/global-error.service";
+import * as i3 from "../../configuration";
+export class SentryErrorHandler {
+    constructor(authorizerService, errorService, config) {
+        this.authorizerService = authorizerService;
+        this.errorService = errorService;
+        if (config?.sentryConfig) {
+            const SENTRY_CONFIG = config.sentryConfig;
+            Sentry.init({
+                dsn: SENTRY_CONFIG?.DSN,
+                integrations: [
+                    new Sentry.BrowserTracing({
+                        tracePropagationTargets: SENTRY_CONFIG.ALLOW_ORIGIN,
+                        routingInstrumentation: Sentry.routingInstrumentation,
+                    }),
+                ],
+                tracesSampleRate: SENTRY_CONFIG.TRACES_SAMPLE_RATE,
+                replaysSessionSampleRate: SENTRY_CONFIG.REPLAY_SESSION_SAMPLE_RATE,
+                replaysOnErrorSampleRate: SENTRY_CONFIG.REPLAY_ON_ERROR_SAMPLE_RATE,
+            });
+            Sentry.setUser({ userDetails: this.authorizerService.getUser() });
+        }
+    }
+    handleError(error) {
+        const ERROR = error?.originalError || error;
+        this.handleChunkError(ERROR);
+        Sentry.captureException(ERROR);
+    }
+    handleChunkError(error) {
+        const chunkFailedMessage = /Loading chunk [\d]+ failed/;
+        if (chunkFailedMessage.test(error?.message)) {
+            window.location.reload();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SentryErrorHandler, deps: [{ token: i1.AuthorizerService }, { token: i2.GlobalErrorService }, { token: i3.Configurations, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SentryErrorHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SentryErrorHandler, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.AuthorizerService }, { type: i2.GlobalErrorService }, { type: i3.Configurations, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/interceptors/http.interceptor.mjs

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import { HttpResponse, } from '@angular/common/http';
+import { throwError } from 'rxjs';
+import { catchError, tap, timeout } from 'rxjs/operators';
+import { API_TIMEOUT_TIME, ERROR_FEATURE_FLAG, } from '../constants/error-handling.constants';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/global-error.service";
+import * as i2 from "../../featureFlag/feature-flag.service";
+export class HttpReqInterceptor {
+    constructor(errorService, featureFlagService) {
+        this.errorService = errorService;
+        this.featureFlagService = featureFlagService;
+    }
+    intercept(req, next) {
+        if (this.featureFlagService.isFeatureEnabled(ERROR_FEATURE_FLAG)) {
+            return next.handle(req).pipe(timeout(API_TIMEOUT_TIME), tap((event) => {
+                if (event instanceof HttpResponse) {
+                    this.errorService.handleSoftErrors(event);
+                }
+            }), catchError((error) => {
+                this.errorService.handleError(error, req);
+                return throwError(error);
+            }));
+        }
+        else {
+            return next.handle(req);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpReqInterceptor, deps: [{ token: i1.GlobalErrorService }, { token: i2.FeatureFlagService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpReqInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HttpReqInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.GlobalErrorService }, { type: i2.FeatureFlagService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/services/global-error.service.mjs

@@ -0,0 +1,115 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { ErrorStatusCode } from '../types/global-error.types';
+import { PAGE_LEVEL_API_CONFIG, COMPONENT_LEVEL_API_CONFIG, } from '../constants/api-config.constants';
+import * as i0 from "@angular/core";
+import * as i1 from "../../ui-kit/snack-bar/snack-bar.service";
+import * as i2 from "./util.service";
+import * as i3 from "@angular/router";
+export class GlobalErrorService {
+    constructor(snackBarService, utilService, router) {
+        this.snackBarService = snackBarService;
+        this.utilService = utilService;
+        this.router = router;
+        this.globalError$ = new Subject();
+        this.localError$ = new Subject();
+        this.pageLevelApiConfig = PAGE_LEVEL_API_CONFIG;
+        this.componentLevelApiConfig = COMPONENT_LEVEL_API_CONFIG;
+    }
+    handleSoftErrors(event) {
+        const xData = event.headers.get('X-Data');
+        if (xData) {
+            const parsedData = JSON.parse(xData);
+            const statusCode = parsedData.statusCode;
+            const statusMessage = parsedData.message;
+            if (statusCode && statusCode !== 0) {
+                this.snackBarService.show(statusMessage || 'Error occurred', 'error');
+            }
+        }
+    }
+    handleError(error, request) {
+        if (this.isUnauthenticated(error) ||
+            this.isUnauthorizedAccess(error) ||
+            this.isNetworkUnavailable(error)) {
+            this.publishGlobalError(error);
+        }
+        else if (this.isServerError(error)) {
+            this.handleServerError(error, request);
+        }
+        else {
+            this.handleSoftErrors(error);
+        }
+    }
+    isServerError(error) {
+        const serverErrorCodes = [
+            ErrorStatusCode.InternalServerError,
+            ErrorStatusCode.ServiceUnavailable,
+            ErrorStatusCode.BadGateway,
+            ErrorStatusCode.RequestTimeout,
+        ];
+        return serverErrorCodes.includes(error.status);
+    }
+    isUnauthenticated(error) {
+        return error.status === ErrorStatusCode.Unauthenticated;
+    }
+    isUnauthorizedAccess(error) {
+        return error.status === ErrorStatusCode.UnauthorizedAccess;
+    }
+    isNetworkUnavailable(error) {
+        return error.status === ErrorStatusCode.NetworkUnavailable;
+    }
+    handleServerError(error, request) {
+        if (this.isPageLevelError(error, request)) {
+            this.publishGlobalError(error);
+        }
+        else if (this.isComponentLevelError(error, request)) {
+            this.publishLocalError(error, request);
+        }
+    }
+    publishGlobalError(error) {
+        this.globalError$.next(error);
+    }
+    publishLocalError(error, request) {
+        this.localError$.next({ error, request });
+    }
+    isPageLevelError(error, request) {
+        const requestDetails = {
+            method: request.method,
+            path: request.url,
+            query: this.utilService.extractQueryParams(request.params),
+            body: request.body,
+            pageCode: this.getPageCode(),
+        };
+        return this.pageLevelApiConfig.some((apiConfig) => this.isApiConfigMatching(apiConfig, requestDetails));
+    }
+    isComponentLevelError(error, request) {
+        const requestDetails = {
+            method: request.method,
+            path: request.url,
+            query: this.utilService.extractQueryParams(request.params),
+            body: request.body,
+        };
+        return this.componentLevelApiConfig.some((apiConfig) => this.isApiConfigMatching(apiConfig, requestDetails));
+    }
+    getPageCode() {
+        const currentRoute = this.router.routerState.snapshot.root.firstChild;
+        return currentRoute?.data?.pageCode;
+    }
+    isApiConfigMatching(apiConfig, requestDetails) {
+        return (this.utilService.isStringEqual(apiConfig.method, requestDetails.method) &&
+            this.utilService.isSubstringInString(apiConfig.path, requestDetails.path) &&
+            this.utilService.isSubsetOfObject(apiConfig.query, requestDetails.query) &&
+            this.utilService.isSubsetOfArray(apiConfig.body, requestDetails.body) &&
+            (!apiConfig.pageCodes ||
+                this.utilService.isValueInArray(apiConfig.pageCodes, requestDetails.pageCode || '')));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GlobalErrorService, deps: [{ token: i1.SnackBarService }, { token: i2.UtilsService }, { token: i3.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GlobalErrorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GlobalErrorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SnackBarService }, { type: i2.UtilsService }, { type: i3.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"global-error.service.js","sourceRoot":"","sources":["../../../../../../projects/vc-error-handlers/src/lib/shared/services/global-error.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  HttpErrorResponse,\r\n  HttpRequest,\r\n  HttpResponse,\r\n} from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { Router } from '@angular/router';\r\nimport { Subject } from 'rxjs';\r\n\r\nimport { SnackBarService } from '../../ui-kit/snack-bar/snack-bar.service';\r\nimport { UtilsService } from './util.service';\r\n\r\nimport { ErrorStatusCode, RequestDetails } from '../types/global-error.types';\r\nimport {\r\n  PAGE_LEVEL_API_CONFIG,\r\n  COMPONENT_LEVEL_API_CONFIG,\r\n} from '../constants/api-config.constants';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class GlobalErrorService {\r\n  public globalError$: Subject<any> = new Subject();\r\n  public localError$: Subject<any> = new Subject();\r\n\r\n  private pageLevelApiConfig = PAGE_LEVEL_API_CONFIG;\r\n  private componentLevelApiConfig = COMPONENT_LEVEL_API_CONFIG;\r\n\r\n  constructor(\r\n    private snackBarService: SnackBarService,\r\n    private utilService: UtilsService,\r\n    private router: Router\r\n  ) {}\r\n\r\n  public handleSoftErrors(event: HttpResponse<any> | HttpErrorResponse) {\r\n    const xData = event.headers.get('X-Data');\r\n\r\n    if (xData) {\r\n      const parsedData = JSON.parse(xData);\r\n      const statusCode = parsedData.statusCode;\r\n      const statusMessage = parsedData.message;\r\n\r\n      if (statusCode && statusCode !== 0) {\r\n        this.snackBarService.show(statusMessage || 'Error occurred', 'error');\r\n      }\r\n    }\r\n  }\r\n\r\n  public handleError(error: HttpErrorResponse, request: HttpRequest<any>) {\r\n    if (\r\n      this.isUnauthenticated(error) ||\r\n      this.isUnauthorizedAccess(error) ||\r\n      this.isNetworkUnavailable(error)\r\n    ) {\r\n      this.publishGlobalError(error);\r\n    } else if (this.isServerError(error)) {\r\n      this.handleServerError(error, request);\r\n    } else {\r\n      this.handleSoftErrors(error);\r\n    }\r\n  }\r\n\r\n  public isServerError(error: HttpErrorResponse): boolean {\r\n    const serverErrorCodes = [\r\n      ErrorStatusCode.InternalServerError,\r\n      ErrorStatusCode.ServiceUnavailable,\r\n      ErrorStatusCode.BadGateway,\r\n      ErrorStatusCode.RequestTimeout,\r\n    ];\r\n\r\n    return serverErrorCodes.includes(error.status);\r\n  }\r\n\r\n  private isUnauthenticated(error: HttpErrorResponse): boolean {\r\n    return error.status === ErrorStatusCode.Unauthenticated;\r\n  }\r\n\r\n  private isUnauthorizedAccess(error: HttpErrorResponse): boolean {\r\n    return error.status === ErrorStatusCode.UnauthorizedAccess;\r\n  }\r\n\r\n  private isNetworkUnavailable(error: HttpErrorResponse): boolean {\r\n    return error.status === ErrorStatusCode.NetworkUnavailable;\r\n  }\r\n\r\n  private handleServerError(\r\n    error: HttpErrorResponse,\r\n    request: HttpRequest<any>\r\n  ) {\r\n    if (this.isPageLevelError(error, request)) {\r\n      this.publishGlobalError(error);\r\n    } else if (this.isComponentLevelError(error, request)) {\r\n      this.publishLocalError(error, request);\r\n    }\r\n  }\r\n\r\n  private publishGlobalError(error: HttpErrorResponse) {\r\n    this.globalError$.next(error);\r\n  }\r\n\r\n  private publishLocalError(\r\n    error: HttpErrorResponse,\r\n    request: HttpRequest<any>\r\n  ) {\r\n    this.localError$.next({ error, request });\r\n  }\r\n\r\n  private isPageLevelError(\r\n    error: HttpErrorResponse,\r\n    request: HttpRequest<any>\r\n  ): boolean {\r\n    const requestDetails: RequestDetails = {\r\n      method: request.method,\r\n      path: request.url,\r\n      query: this.utilService.extractQueryParams(request.params),\r\n      body: request.body,\r\n      pageCode: this.getPageCode(),\r\n    };\r\n\r\n    return this.pageLevelApiConfig.some((apiConfig) =>\r\n      this.isApiConfigMatching(apiConfig, requestDetails)\r\n    );\r\n  }\r\n\r\n  private isComponentLevelError(\r\n    error: HttpErrorResponse,\r\n    request: HttpRequest<any>\r\n  ): boolean {\r\n    const requestDetails: RequestDetails = {\r\n      method: request.method,\r\n      path: request.url,\r\n      query: this.utilService.extractQueryParams(request.params),\r\n      body: request.body,\r\n    };\r\n\r\n    return this.componentLevelApiConfig.some((apiConfig) =>\r\n      this.isApiConfigMatching(apiConfig, requestDetails)\r\n    );\r\n  }\r\n\r\n  private getPageCode() {\r\n    const currentRoute = this.router.routerState.snapshot.root.firstChild;\r\n    return currentRoute?.data?.pageCode;\r\n  }\r\n\r\n  private isApiConfigMatching(\r\n    apiConfig: any,\r\n    requestDetails: RequestDetails\r\n  ): boolean {\r\n    return (\r\n      this.utilService.isStringEqual(apiConfig.method, requestDetails.method) &&\r\n      this.utilService.isSubstringInString(\r\n        apiConfig.path,\r\n        requestDetails.path\r\n      ) &&\r\n      this.utilService.isSubsetOfObject(\r\n        apiConfig.query,\r\n        requestDetails.query\r\n      ) &&\r\n      this.utilService.isSubsetOfArray(apiConfig.body, requestDetails.body) &&\r\n      (!apiConfig.pageCodes ||\r\n        this.utilService.isValueInArray(\r\n          apiConfig.pageCodes,\r\n          requestDetails.pageCode || ''\r\n        ))\r\n    );\r\n  }\r\n}\r\n"]}