vc-error-handlers 1.0.1 → 9.0.0

package/package.json

@@ -1,26 +1,27 @@
 {
   "name": "vc-error-handlers",
-  "version": "1.0.1",
+  "version": "9.0.0",
   "peerDependencies": {
-    "@angular/common": " 13.x || 14.x || 15.x || 16.x || 17.x || 18.x || 19.x || 20.x",
-    "@angular/core": "13.x || 14.x || 15.x || 16.x || 17.x || 18.x || 19.x || 20.x"
+    "@angular/common": " 13.x || 14.x || 15.x || 16.x || 17.x || 18.x || 19.x || 20.x || 21.x || 22.x || 23.x || 24.x ",
+    "@angular/core": "13.x || 14.x || 15.x || 16.x || 17.x || 18.x || 19.x || 20.x || 21.x || 22.x || 23.x || 24.x"
   },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
   "module": "fesm2022/vc-error-handlers.mjs",
-  "typings": "index.d.ts",
+  "typings": "types/vc-error-handlers.d.ts",
   "exports": {
     "./package.json": {
       "default": "./package.json"
     },
     ".": {
-      "types": "./index.d.ts",
+      "types": "./types/vc-error-handlers.d.ts",
       "default": "./fesm2022/vc-error-handlers.mjs"
     }
   },
   "sideEffects": false,
+  "type": "module",
   "dependencies": {
     "tslib": "^2.3.0"
   }

package/types/vc-error-handlers.d.ts

@@ -0,0 +1,543 @@
+import * as i0 from "@angular/core";
+import { AfterViewInit, ApplicationRef, ChangeDetectorRef, ComponentRef, ElementRef, EnvironmentInjector, EventEmitter, InjectionToken, Injector, ModuleWithProviders, OnDestroy, OnInit, Renderer2, TemplateRef, Type, ViewContainerRef } from "@angular/core";
+import { HttpClient, HttpErrorResponse, HttpEvent, HttpHandler, HttpInterceptor, HttpParams, HttpRequest, HttpResponse } from "@angular/common/http";
+import { ActivatedRoute, Router } from "@angular/router";
+import { Observable, Subject, Subscription } from "rxjs";
+import { AuthorizerService } from "@vcomply/authorizer";
+import { BrowserOptions } from "@sentry/browser";
+import * as i3 from "@angular/common";
+export declare class VcErrorHandlersService {
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<VcErrorHandlersService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+declare class SnackBarService {
+  snackbarSubject: Subject<any>;
+  snackbarState: import("rxjs").Observable<any>;
+  constructor();
+  show(message: string, type?: 'success' | 'warning' | 'info' | 'alert' | 'error'): void;
+  hide(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SnackBarService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+declare class UtilsService {
+  private isJsonSubset;
+  extractQueryParams(params: HttpParams): {
+    [key: string]: any;
+  };
+  isStringEqual(apiMethod: string, requestMethod: string): boolean;
+  isSubstringInString(apiPath: string, requestPath: string): boolean;
+  isSubsetOfObject(apiQuery: any, requestQuery: any): boolean;
+  isSubsetOfArray(apiBody: any, requestBody: any): boolean;
+  isValueInArray(apiPageCodes: string[], pageCode: string): boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UtilsService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class GlobalErrorService {
+  private snackBarService;
+  private utilService;
+  private router;
+  globalError$: Subject<any>;
+  localError$: Subject<any>;
+  private pageLevelApiConfig;
+  private componentLevelApiConfig;
+  private excludeApiConfig;
+  constructor(snackBarService: SnackBarService, utilService: UtilsService, router: Router);
+  handleSoftErrors(event: HttpResponse<any> | HttpErrorResponse): void;
+  handleError(error: HttpErrorResponse, request: HttpRequest<any>): void;
+  isServerError(error: HttpErrorResponse): boolean;
+  isExcludeErrorHandling(request: HttpRequest<any>): boolean;
+  private isUnauthenticated;
+  private isUnauthorizedAccess;
+  private isNetworkUnavailable;
+  private handleServerError;
+  private publishGlobalError;
+  private publishLocalError;
+  private isPageLevelError;
+  private isComponentLevelError;
+  private getPageCode;
+  private isApiConfigMatching;
+  static ɵfac: i0.ɵɵFactoryDeclaration<GlobalErrorService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class RouterService {
+  baseUrl: string;
+  constructor();
+  private setBaseUrl;
+  redirectToLogin(): void;
+  redirectToHome(module_name: string): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RouterService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+declare class Configurations {
+  sentryConfig: any;
+  envConfig: any;
+  isErrorInterceptorEnabled?: boolean;
+  constructor();
+}
+declare class FeatureFlagService {
+  private http;
+  private authorizer;
+  environment: any;
+  flagFetchError: boolean;
+  featuresMap: any;
+  AWSFlags: any;
+  flagSubscription: Subscription;
+  constructor(http: HttpClient, authorizer: AuthorizerService, config?: Configurations);
+  fetchFlags(): import("rxjs").Observable<Object>;
+  loadConfig(): Promise<unknown>;
+  buildFeatureFlags(orgId: any): void;
+  isFeatureEnabled(featureFlag: string): any;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FeatureFlagService, [null, null, {
+    optional: true;
+  }]>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class VcErrorHandlersComponent implements OnInit, OnDestroy {
+  private errorService;
+  private snackBarService;
+  private featureFlagService;
+  private errorConfig;
+  unauthorized: boolean;
+  sessionExpired: boolean;
+  chunkUnavailable: boolean;
+  serverError: boolean;
+  isOnline: boolean;
+  disableSnackBar: boolean;
+  feature: FeatureFlagService;
+  constructor(errorService: GlobalErrorService, snackBarService: SnackBarService, featureFlagService: FeatureFlagService);
+  ngOnInit(): void;
+  ngOnDestroy(): void;
+  private subscribeGlobalError;
+  private handleError;
+  private subscribeNetworkDetection;
+  private onNetworkOnline;
+  private onNetworkOffline;
+  private handleNetworkError;
+  private showOfflineSnackBar;
+  private hideSnackBar;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VcErrorHandlersComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<VcErrorHandlersComponent, "lib-vc-error-handlers", never, {
+    "disableSnackBar": {
+      "alias": "disableSnackBar";
+      "required": false;
+    };
+    "feature": {
+      "alias": "feature";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+export declare class PageNotFoundComponent {
+  private route;
+  private routerService;
+  errorConfig: {
+    imageUrl: string;
+    title: string;
+    description: string;
+    details: string;
+    buttonText: string;
+  };
+  VcomplyLogo: string;
+  altImageText: {
+    ERROR_IMAGE: string;
+    VCOMPLY_LOGO: string;
+  };
+  currentYear: number;
+  organisationName: string;
+  defaultURL: string;
+  constructor(route: ActivatedRoute, routerService: RouterService);
+  redirectToDashboard(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<PageNotFoundComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<PageNotFoundComponent, "lib-vc-error-page-not-found", never, {}, {}, never, never, false, never>;
+}
+export declare class UnauthorizedComponent {
+  private route;
+  private routerService;
+  constructor(route: ActivatedRoute, routerService: RouterService);
+  currentYear: number;
+  errorConfig: {
+    imageUrl: string;
+    title: string;
+    description: string;
+    details: string;
+    email: string;
+    support: string;
+    buttonText: string;
+    mail: string;
+  };
+  VcomplyLogo: string;
+  altImageText: {
+    ERROR_IMAGE: string;
+    VCOMPLY_LOGO: string;
+  };
+  organisationName: string;
+  defaultURL: string;
+  redirectToDashboard(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UnauthorizedComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UnauthorizedComponent, "lib-vc-error-unauthorized", never, {}, {}, never, never, false, never>;
+}
+declare class InsertionDirective {
+  viewContainerRef: ViewContainerRef;
+  constructor(viewContainerRef: ViewContainerRef);
+  static ɵfac: i0.ɵɵFactoryDeclaration<InsertionDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<InsertionDirective, "[appInsertion]", never, {}, {}, never, never, false, never>;
+}
+declare class DialogRef {
+  private readonly afterDialogClosed;
+  afterClosed: Observable<any>;
+  constructor();
+  close(result?: any): void;
+}
+declare class DialogConfig<D = any> {
+  data?: D;
+  position?: any;
+  background?: any;
+  pointer?: any;
+}
+declare class DialogComponent implements AfterViewInit, OnDestroy, OnInit {
+  private cd;
+  private dialogRef;
+  config: DialogConfig;
+  private router;
+  componentRef: ComponentRef<any>;
+  position: any;
+  background: any;
+  pointer: any;
+  insertionPoint: InsertionDirective;
+  animation: boolean;
+  private readonly onDialogClose;
+  onClose: import("rxjs").Observable<any>;
+  childComponentType: Type<any>;
+  constructor(cd: ChangeDetectorRef, dialogRef: DialogRef, config: DialogConfig, router: Router);
+  ngOnInit(): void;
+  routeAction(): void;
+  ngAfterViewInit(): void;
+  onOverlayClicked(evt: MouseEvent): void;
+  onDialogClicked(evt: MouseEvent): void;
+  loadChildComponent(componentType: Type<any>): void;
+  ngOnDestroy(): void;
+  close(data?: any): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DialogComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<DialogComponent, "app-dialog", never, {}, {}, never, never, false, never>;
+}
+declare class DialogService {
+  private appRef;
+  private injector;
+  private environmentInjector;
+  dialogComponentRef: ComponentRef<DialogComponent>;
+  constructor(appRef: ApplicationRef, injector: Injector, environmentInjector: EnvironmentInjector);
+  open(componentType: Type<any>, config: DialogConfig): DialogRef;
+  private appendDialogComponentToBody;
+  private removeDialogComponentFromBody;
+  static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class ChunkUnavailableComponent implements OnInit {
+  private dialogService;
+  errorConfig: {
+    heading: string;
+    description: string;
+    buttonText: string;
+  };
+  errorType: {
+    CHUNK_NOT_FOUND: string;
+    SESSION_EXPIRED: string;
+  };
+  constructor(dialogService: DialogService);
+  ngOnInit(): void;
+  private openSessionExpiredModal;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ChunkUnavailableComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ChunkUnavailableComponent, "lib-vc-error-chunk-unavailable", never, {}, {}, never, never, false, never>;
+}
+export declare class ServerErrorComponent {
+  errorConfig: {
+    imageUrl: string;
+    title: string;
+    description: string;
+    details: string;
+    buttonText: string;
+    snackBarMessage: string;
+  };
+  VcomplyLogo: string;
+  altImageText: {
+    ERROR_IMAGE: string;
+    VCOMPLY_LOGO: string;
+  };
+  refreshPage(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ServerErrorComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ServerErrorComponent, "lib-vc-error-server-error", never, {}, {}, never, never, false, never>;
+}
+export declare class SessionExpiredComponent implements OnInit {
+  private dialogService;
+  errorConfig: {
+    heading: string;
+    description: string;
+    buttonText: string;
+  };
+  errorTypes: {
+    CHUNK_NOT_FOUND: string;
+    SESSION_EXPIRED: string;
+  };
+  constructor(dialogService: DialogService);
+  ngOnInit(): void;
+  private openSessionExpiredModal;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SessionExpiredComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SessionExpiredComponent, "lib-vc-error-session-expired", never, {}, {}, never, never, false, never>;
+}
+declare const VCOMPLY_LOGO_URL: string;
+declare const API_TIMEOUT_TIME: number;
+declare const ORGANISATION_NAME = "VCOMPLY TECHNOLOGIES, INC.";
+declare const ERROR_FEATURE_FLAG = "ff_error_handling";
+declare const ERROR_CONFIG: {
+  PAGE_NOT_FOUND: {
+    imageUrl: string;
+    title: string;
+    description: string;
+    details: string;
+    buttonText: string;
+  };
+  UNAUTHORIZED: {
+    imageUrl: string;
+    title: string;
+    description: string;
+    details: string;
+    email: string;
+    support: string;
+    buttonText: string;
+    mail: string;
+  };
+  SESSION_EXPIRED: {
+    heading: string;
+    description: string;
+    buttonText: string;
+  };
+  CHUNK_UNAVAILABLE: {
+    heading: string;
+    description: string;
+    buttonText: string;
+  };
+  SERVER_ERROR: {
+    imageUrl: string;
+    title: string;
+    description: string;
+    details: string;
+    buttonText: string;
+    snackBarMessage: string;
+  };
+  COMPONENT_LEVEL_SERVER_ERROR: {
+    imageUrl: string;
+    title: string;
+    description: string;
+    details: string;
+    buttonText: string;
+  };
+  NETWORK_UNAVAILABLE: {
+    offlineMessage: string;
+  };
+};
+declare const REDIRECTION_URL: {
+  COMPLIANCE_DASHBOARD: string;
+  RISK_DASHBOARD: string;
+  POLICY_DASHBOARD: string;
+  ISSUE_DASHBOARD: string;
+  CASEOPS_DASHBOARD: string;
+  DEFAULT: string;
+};
+declare const MODULE_NAMES: {
+  RISK: string;
+  POLICY: string;
+  ISSUE: string;
+  CASEOPS: string;
+};
+declare const MODAL_ERROR_TYPES: {
+  CHUNK_NOT_FOUND: string;
+  SESSION_EXPIRED: string;
+};
+declare const ALT_IMAGE_TEXT: {
+  ERROR_IMAGE: string;
+  VCOMPLY_LOGO: string;
+};
+interface DialogData {
+  heading: string;
+  description: string;
+  buttonText: string;
+}
+interface RequestDetails {
+  method: string;
+  path: string;
+  query: {
+    [key: string]: any;
+  };
+  body: any;
+  pageCode?: string;
+}
+declare enum ErrorStatusCode {
+  URLNotFound = 404,
+  UnauthorizedAccess = 403,
+  Unauthenticated = 401,
+  InternalServerError = 500,
+  ServiceUnavailable = 503,
+  BadGateway = 502,
+  RequestTimeout = 504,
+  NetworkUnavailable = 0,
+  JSChunkUnavailable = 600
+}
+type ModalErrorType = keyof typeof MODAL_ERROR_TYPES;
+export declare class ErrorModalComponent {
+  private authService;
+  private dialogConfig;
+  private routerService;
+  errorTypes: {
+    CHUNK_NOT_FOUND: string;
+    SESSION_EXPIRED: string;
+  };
+  errorType: ModalErrorType | undefined;
+  data: DialogData;
+  constructor(authService: AuthorizerService, dialogConfig: DialogConfig, routerService: RouterService);
+  private setDataConfig;
+  onContinueAction(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ErrorModalComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ErrorModalComponent, "lib-vc-error-modal", never, {
+    "errorType": {
+      "alias": "errorType";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+export declare class ComponentLevelServerErrorComponent {
+  errorConfig: {
+    imageUrl: string;
+    title: string;
+    description: string;
+    details: string;
+    buttonText: string;
+  };
+  altImageText: {
+    ERROR_IMAGE: string;
+    VCOMPLY_LOGO: string;
+  };
+  onClick: EventEmitter<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ComponentLevelServerErrorComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ComponentLevelServerErrorComponent, "lib-vc-error-component-server-error", never, {}, {
+    "onClick": "onClick";
+  }, never, never, false, never>;
+}
+declare class DialogModule {
+  static ɵfac: i0.ɵɵFactoryDeclaration<DialogModule, never>;
+  static ɵmod: i0.ɵɵNgModuleDeclaration<DialogModule, [typeof DialogComponent, typeof InsertionDirective], [typeof i3.CommonModule], [typeof DialogComponent]>;
+  static ɵinj: i0.ɵɵInjectorDeclaration<DialogModule>;
+}
+declare class FeatureFlagDirective implements OnInit {
+  private tpl;
+  private vcr;
+  private featureFlagService;
+  featureFlag: string;
+  constructor(tpl: TemplateRef<any>, vcr: ViewContainerRef, featureFlagService: FeatureFlagService);
+  ngOnInit(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<FeatureFlagDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<FeatureFlagDirective, "[featureFlag]", never, {
+    "featureFlag": {
+      "alias": "featureFlag";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+declare class FeatureFlagModule {
+  static ɵfac: i0.ɵɵFactoryDeclaration<FeatureFlagModule, never>;
+  static ɵmod: i0.ɵɵNgModuleDeclaration<FeatureFlagModule, [typeof FeatureFlagDirective], [typeof i3.CommonModule], [typeof FeatureFlagDirective]>;
+  static ɵinj: i0.ɵɵInjectorDeclaration<FeatureFlagModule>;
+}
+declare class SnackBarComponent implements OnInit, OnDestroy {
+  private snackbarService;
+  show: boolean;
+  message: string;
+  icon: string;
+  type: string;
+  icons: any;
+  snackbarSubscription: Subscription;
+  constructor(snackbarService: SnackBarService);
+  ngOnInit(): void;
+  setAutoClose(): void;
+  close(): void;
+  ngOnDestroy(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SnackBarComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SnackBarComponent, "app-snack-bar", never, {}, {}, never, never, false, never>;
+}
+declare class SnackBarModule {
+  static ɵfac: i0.ɵɵFactoryDeclaration<SnackBarModule, never>;
+  static ɵmod: i0.ɵɵNgModuleDeclaration<SnackBarModule, [typeof SnackBarComponent], [typeof i3.CommonModule], [typeof SnackBarComponent]>;
+  static ɵinj: i0.ɵɵInjectorDeclaration<SnackBarModule>;
+}
+declare class ToolTipDirective implements OnInit {
+  private el;
+  private renderer;
+  tooltipTitle: string;
+  placement: string;
+  type: any;
+  tooltipMandatory: boolean;
+  showTooltip: boolean;
+  animate: boolean;
+  tooltip: HTMLElement;
+  offset: number;
+  constructor(el: ElementRef, renderer: Renderer2);
+  ngOnInit(): void;
+  onMouseEnter(): void;
+  onMouseOver(): void;
+  onMouseLeave(): void;
+  onMouseOut(): void;
+  onClick(): void;
+  show(): void;
+  hide(): void;
+  create(): void;
+  setPosition(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ToolTipDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<ToolTipDirective, "[arTooltip]", never, {
+    "tooltipTitle": {
+      "alias": "arTooltip";
+      "required": false;
+    };
+    "placement": {
+      "alias": "placement";
+      "required": false;
+    };
+    "type": {
+      "alias": "type";
+      "required": false;
+    };
+    "tooltipMandatory": {
+      "alias": "tooltipMandatory";
+      "required": false;
+    };
+    "showTooltip": {
+      "alias": "showTooltip";
+      "required": false;
+    };
+    "animate": {
+      "alias": "animate";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+declare class TooltipModule {
+  static ɵfac: i0.ɵɵFactoryDeclaration<TooltipModule, never>;
+  static ɵmod: i0.ɵɵNgModuleDeclaration<TooltipModule, [typeof ToolTipDirective], [typeof i3.CommonModule], [typeof ToolTipDirective]>;
+  static ɵinj: i0.ɵɵInjectorDeclaration<TooltipModule>;
+}
+export declare const FOR_ROOT_SENTRY_OPTIONS_TOKEN: InjectionToken<BrowserOptions>;
+export declare class VcErrorHandlersModule {
+  private loadConfig;
+  constructor(loadConfig: FeatureFlagService);
+  static forRoot(environmentConfig: Configurations): ModuleWithProviders<VcErrorHandlersModule>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<VcErrorHandlersModule, never>;
+  static ɵmod: i0.ɵɵNgModuleDeclaration<VcErrorHandlersModule, [typeof VcErrorHandlersComponent, typeof PageNotFoundComponent, typeof UnauthorizedComponent, typeof SessionExpiredComponent, typeof ChunkUnavailableComponent, typeof ServerErrorComponent, typeof ErrorModalComponent, typeof ComponentLevelServerErrorComponent], [typeof i3.CommonModule, typeof DialogModule, typeof FeatureFlagModule, typeof i3.NgOptimizedImage, typeof SnackBarModule, typeof TooltipModule], [typeof VcErrorHandlersComponent, typeof PageNotFoundComponent, typeof UnauthorizedComponent, typeof SessionExpiredComponent, typeof ChunkUnavailableComponent, typeof ServerErrorComponent, typeof ErrorModalComponent, typeof ComponentLevelServerErrorComponent]>;
+  static ɵinj: i0.ɵɵInjectorDeclaration<VcErrorHandlersModule>;
+}
+export declare class HttpReqInterceptor implements HttpInterceptor {
+  private errorService;
+  constructor(errorService: GlobalErrorService);
+  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HttpReqInterceptor, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export {};