@pagopa/selfcare-common-frontend 1.35.0 → 1.36.0

package/lib/model/User.d.ts

@@ -0,0 +1,8 @@
+export type User = {
+    uid: string;
+    taxCode?: string;
+    name?: string;
+    surname?: string;
+    email?: string;
+    iss?: string;
+};

package/lib/model/User.js

@@ -0,0 +1 @@
+export {};

package/{model → lib/model}/UserNotify.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="react" />
-export declare type UserNotify = {
+export type UserNotify = {
     /** The identifier used to recognize the user notify: it cannot be possible to have the same error id at the same time */
     id: string;
     /** The title to show in the popup or toast */

package/lib/model/UserNotify.js

@@ -0,0 +1 @@
+export {};

package/lib/redux/slices/appStateSlice.d.ts

@@ -0,0 +1,58 @@
+import { AppError } from '../../model/AppError';
+import { UserNotify } from '../../model/UserNotify';
+export type { AppError } from '../../model/AppError';
+interface AppStateState {
+    loading: {
+        result: boolean;
+        tasks: {
+            [taskId: string]: boolean;
+        };
+    };
+    errors: Array<AppError>;
+    userNotifies: Array<UserNotify>;
+    unloadEventConfiguration: {
+        enabled: boolean;
+        open: boolean;
+        title?: string;
+        description?: string;
+        exitAction?: () => void;
+    };
+}
+export declare const appStateActions: {
+    setLoading: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+        task: string;
+        loading: boolean;
+    }, "appState/setLoading">;
+    addError: import("@reduxjs/toolkit").ActionCreatorWithPayload<AppError, "appState/addError">;
+    removeError: import("@reduxjs/toolkit").ActionCreatorWithPayload<AppError, "appState/removeError">;
+    addNotify: import("@reduxjs/toolkit").ActionCreatorWithPayload<UserNotify, "appState/addNotify">;
+    removeNotify: import("@reduxjs/toolkit").ActionCreatorWithPayload<UserNotify, "appState/removeNotify">;
+    enableUnloadEventInterceptor: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+        title?: string;
+        description?: string;
+    }, "appState/enableUnloadEventInterceptor">;
+    disableUnloadEventInterceptor: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"appState/disableUnloadEventInterceptor">;
+    openUnloadEventNotify: import("@reduxjs/toolkit").ActionCreatorWithPayload<() => void, "appState/openUnloadEventNotify">;
+    closeUnloadEventNotify: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"appState/closeUnloadEventNotify">;
+};
+export declare const appStateReducer: import("redux").Reducer<AppStateState>;
+export declare const appStateSelectors: {
+    selectLoading: (state: {
+        appState: AppStateState;
+    }) => boolean;
+    selectErrors: (state: {
+        appState: AppStateState;
+    }) => AppError[];
+    selectNotifies: (state: {
+        appState: AppStateState;
+    }) => UserNotify[];
+    selectUnloadEventConfiguration: (state: {
+        appState: AppStateState;
+    }) => {
+        enabled: boolean;
+        open: boolean;
+        title?: string;
+        description?: string;
+        exitAction?: () => void;
+    };
+};

package/{redux → lib/redux}/slices/appStateSlice.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.appStateSelectors = exports.appStateReducer = exports.appStateActions = exports.appStateSlice = void 0;
-const toolkit_1 = require("@reduxjs/toolkit");
+import { createSlice } from '@reduxjs/toolkit';
 const initialState = {
     loading: {
         result: false,
@@ -23,7 +20,7 @@ const keepOnPage = (e) => {
     return message;
 };
 /* eslint-disable functional/immutable-data */
-exports.appStateSlice = (0, toolkit_1.createSlice)({
+const appStateSlice = createSlice({
     name: 'appState',
     initialState,
     reducers: {
@@ -101,12 +98,21 @@ exports.appStateSlice = (0, toolkit_1.createSlice)({
         },
     },
 });
-exports.appStateActions = exports.appStateSlice.actions;
-exports.appStateReducer = exports.appStateSlice.reducer;
-exports.appStateSelectors = {
+export const appStateActions = {
+    setLoading: appStateSlice.actions.setLoading,
+    addError: appStateSlice.actions.addError,
+    removeError: appStateSlice.actions.removeError,
+    addNotify: appStateSlice.actions.addNotify,
+    removeNotify: appStateSlice.actions.removeNotify,
+    enableUnloadEventInterceptor: appStateSlice.actions.enableUnloadEventInterceptor,
+    disableUnloadEventInterceptor: appStateSlice.actions.disableUnloadEventInterceptor,
+    openUnloadEventNotify: appStateSlice.actions.openUnloadEventNotify,
+    closeUnloadEventNotify: appStateSlice.actions.closeUnloadEventNotify,
+};
+export const appStateReducer = appStateSlice.reducer;
+export const appStateSelectors = {
     selectLoading: (state) => state.appState.loading.result,
     selectErrors: (state) => state.appState.errors,
     selectNotifies: (state) => state.appState.userNotifies,
     selectUnloadEventConfiguration: (state) => state.appState.unloadEventConfiguration,
 };
-//# sourceMappingURL=appStateSlice.js.map

package/lib/redux/slices/permissionsSlice.d.ts

@@ -0,0 +1,12 @@
+export interface ProductPermissions {
+    productId: string;
+    actions: Array<string>;
+}
+export interface PermissionsState {
+    productPermissions: Array<ProductPermissions>;
+}
+export declare const setProductPermissions: import("@reduxjs/toolkit").ActionCreatorWithPayload<ProductPermissions[], "permissions/setProductPermissions">, resetPermissions: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"permissions/resetPermissions">;
+export declare const permissionsReducer: import("redux").Reducer<PermissionsState>;
+export declare const selectProductPermissions: (state: {
+    permissions: PermissionsState;
+}) => ProductPermissions[];

package/lib/redux/slices/permissionsSlice.js

@@ -0,0 +1,23 @@
+import { createSlice } from '@reduxjs/toolkit';
+const initialState = {
+    productPermissions: [],
+};
+const permissionsSlice = createSlice({
+    name: 'permissions',
+    initialState,
+    reducers: {
+        setProductPermissions: (state, action) => ({
+            ...state,
+            productPermissions: action.payload,
+        }),
+        resetPermissions: (state) => ({
+            ...state,
+            productPermissions: [],
+        }),
+    },
+});
+// Actions
+export const { setProductPermissions, resetPermissions } = permissionsSlice.actions;
+export const permissionsReducer = permissionsSlice.reducer;
+// Selectors
+export const selectProductPermissions = (state) => state.permissions.productPermissions;

package/lib/redux/slices/productsSlice.d.ts

@@ -0,0 +1,204 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+export declare enum StatusEnum {
+    'ACTIVE' = "ACTIVE",
+    'TESTING' = "TESTING",
+    'PHASE_OUT' = "PHASE_OUT",
+    'INACTIVE' = "INACTIVE"
+}
+export interface SubProductResource {
+    /** Product's unique identifier */
+    id: string;
+    /** Product's title */
+    title: string;
+    /** Product's onBoarding status */
+    productOnBoardingStatus: 'ACTIVE' | 'PENDING' | 'INACTIVE';
+    /** Product's status */
+    status: StatusEnum;
+    /** If a product is delegable to a technical partner */
+    delegable: boolean;
+    /** Product's depict image */
+    imageUrl: string;
+    /** Product's logo */
+    logo: string;
+    /** Product logo's background color */
+    logoBgColor: string;
+    /** Product's description */
+    description: string;
+    /** URL that redirects to the public information webpage of the product */
+    urlPublic: string;
+    /** If a product is invoiceable */
+    invoiceable: boolean;
+}
+export interface Product {
+    description: string;
+    id: string;
+    logo: string;
+    title: string;
+    urlBO: string;
+    backOfficeEnvironmentConfigurations?: Array<{
+        environment?: string;
+        url?: string;
+    }>;
+    urlPublic?: string;
+    tag?: string;
+    status: StatusEnum;
+    imageUrl: string;
+    subProducts?: Array<SubProductResource>;
+    logoBgColor?: string;
+    delegable: boolean;
+    invoiceable?: boolean;
+}
+export declare const InitialState: never[];
+export declare const productsSlice: import("@reduxjs/toolkit").Slice<Product[], {
+    setProducts: (state: {
+        description: string;
+        id: string;
+        logo: string;
+        title: string;
+        urlBO: string;
+        backOfficeEnvironmentConfigurations?: {
+            environment?: string | undefined;
+            url?: string | undefined;
+        }[] | undefined;
+        urlPublic?: string | undefined;
+        tag?: string | undefined;
+        status: StatusEnum;
+        imageUrl: string;
+        subProducts?: {
+            id: string;
+            title: string;
+            productOnBoardingStatus: "ACTIVE" | "PENDING" | "INACTIVE";
+            status: StatusEnum;
+            delegable: boolean;
+            imageUrl: string;
+            logo: string;
+            logoBgColor: string;
+            description: string;
+            urlPublic: string;
+            invoiceable: boolean;
+        }[] | undefined;
+        logoBgColor?: string | undefined;
+        delegable: boolean;
+        invoiceable?: boolean | undefined;
+    }[], action: PayloadAction<Array<Product>>) => {
+        [x: number]: Product | {
+            description: string;
+            id: string;
+            logo: string;
+            title: string;
+            urlBO: string;
+            backOfficeEnvironmentConfigurations?: {
+                environment?: string | undefined;
+                url?: string | undefined;
+            }[] | undefined;
+            urlPublic?: string | undefined;
+            tag?: string | undefined;
+            status: StatusEnum;
+            imageUrl: string;
+            subProducts?: {
+                id: string;
+                title: string;
+                productOnBoardingStatus: "ACTIVE" | "PENDING" | "INACTIVE";
+                status: StatusEnum;
+                delegable: boolean;
+                imageUrl: string;
+                logo: string;
+                logoBgColor: string;
+                description: string;
+                urlPublic: string;
+                invoiceable: boolean;
+            }[] | undefined;
+            logoBgColor?: string | undefined;
+            delegable: boolean;
+            invoiceable?: boolean | undefined;
+        };
+        length: number;
+        toString(): string;
+        toLocaleString(): string;
+        toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
+        pop(): Product | undefined;
+        push(...items: Product[]): number;
+        concat(...items: ConcatArray<Product>[]): Product[];
+        concat(...items: (Product | ConcatArray<Product>)[]): Product[];
+        join(separator?: string): string;
+        reverse(): Product[];
+        shift(): Product | undefined;
+        slice(start?: number, end?: number): Product[];
+        sort(compareFn?: ((a: Product, b: Product) => number) | undefined): Product[];
+        splice(start: number, deleteCount?: number): Product[];
+        splice(start: number, deleteCount: number, ...items: Product[]): Product[];
+        unshift(...items: Product[]): number;
+        indexOf(searchElement: Product, fromIndex?: number): number;
+        lastIndexOf(searchElement: Product, fromIndex?: number): number;
+        every<S extends Product>(predicate: (value: Product, index: number, array: Product[]) => value is S, thisArg?: any): this is S[];
+        every(predicate: (value: Product, index: number, array: Product[]) => unknown, thisArg?: any): boolean;
+        some(predicate: (value: Product, index: number, array: Product[]) => unknown, thisArg?: any): boolean;
+        forEach(callbackfn: (value: Product, index: number, array: Product[]) => void, thisArg?: any): void;
+        map<U>(callbackfn: (value: Product, index: number, array: Product[]) => U, thisArg?: any): U[];
+        filter<S extends Product>(predicate: (value: Product, index: number, array: Product[]) => value is S, thisArg?: any): S[];
+        filter(predicate: (value: Product, index: number, array: Product[]) => unknown, thisArg?: any): Product[];
+        reduce(callbackfn: (previousValue: Product, currentValue: Product, currentIndex: number, array: Product[]) => Product): Product;
+        reduce(callbackfn: (previousValue: Product, currentValue: Product, currentIndex: number, array: Product[]) => Product, initialValue: Product): Product;
+        reduce<U>(callbackfn: (previousValue: U, currentValue: Product, currentIndex: number, array: Product[]) => U, initialValue: U): U;
+        reduceRight(callbackfn: (previousValue: Product, currentValue: Product, currentIndex: number, array: Product[]) => Product): Product;
+        reduceRight(callbackfn: (previousValue: Product, currentValue: Product, currentIndex: number, array: Product[]) => Product, initialValue: Product): Product;
+        reduceRight<U>(callbackfn: (previousValue: U, currentValue: Product, currentIndex: number, array: Product[]) => U, initialValue: U): U;
+        find<S extends Product>(predicate: (value: Product, index: number, obj: Product[]) => value is S, thisArg?: any): S | undefined;
+        find(predicate: (value: Product, index: number, obj: Product[]) => unknown, thisArg?: any): Product | undefined;
+        findIndex(predicate: (value: Product, index: number, obj: Product[]) => unknown, thisArg?: any): number;
+        fill(value: Product, start?: number, end?: number): Product[];
+        copyWithin(target: number, start: number, end?: number): Product[];
+        entries(): ArrayIterator<[number, Product]>;
+        keys(): ArrayIterator<number>;
+        values(): ArrayIterator<Product>;
+        includes(searchElement: Product, fromIndex?: number): boolean;
+        flatMap<U, This = undefined>(callback: (this: This, value: Product, index: number, array: Product[]) => U | readonly U[], thisArg?: This | undefined): U[];
+        flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
+        [Symbol.iterator](): ArrayIterator<Product>;
+        [Symbol.unscopables]: {
+            [x: number]: boolean | undefined;
+            length?: boolean | undefined;
+            toString?: boolean | undefined;
+            toLocaleString?: boolean | undefined;
+            pop?: boolean | undefined;
+            push?: boolean | undefined;
+            concat?: boolean | undefined;
+            join?: boolean | undefined;
+            reverse?: boolean | undefined;
+            shift?: boolean | undefined;
+            slice?: boolean | undefined;
+            sort?: boolean | undefined;
+            splice?: boolean | undefined;
+            unshift?: boolean | undefined;
+            indexOf?: boolean | undefined;
+            lastIndexOf?: boolean | undefined;
+            every?: boolean | undefined;
+            some?: boolean | undefined;
+            forEach?: boolean | undefined;
+            map?: boolean | undefined;
+            filter?: boolean | undefined;
+            reduce?: boolean | undefined;
+            reduceRight?: boolean | undefined;
+            find?: boolean | undefined;
+            findIndex?: boolean | undefined;
+            fill?: boolean | undefined;
+            copyWithin?: boolean | undefined;
+            entries?: boolean | undefined;
+            keys?: boolean | undefined;
+            values?: boolean | undefined;
+            includes?: boolean | undefined;
+            flatMap?: boolean | undefined;
+            flat?: boolean | undefined;
+            [Symbol.iterator]?: boolean | undefined;
+            readonly [Symbol.unscopables]?: boolean | undefined;
+            at?: boolean | undefined;
+        };
+        at(index: number): Product | undefined;
+    };
+    resetProducts: () => never[];
+}, "products", "products", import("@reduxjs/toolkit").SliceSelectors<Product[]>>;
+export declare const setProducts: import("@reduxjs/toolkit").ActionCreatorWithPayload<Product[], "products/setProducts">, resetProducts: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"products/resetProducts">;
+export declare const productsReducer: import("redux").Reducer<Product[]>;
+export declare const selectProducts: (state: {
+    products: Array<Product>;
+}) => Product[];

package/lib/redux/slices/productsSlice.js

@@ -0,0 +1,26 @@
+/* eslint-disable functional/immutable-data */
+import { createSlice } from '@reduxjs/toolkit';
+export var StatusEnum;
+(function (StatusEnum) {
+    StatusEnum["ACTIVE"] = "ACTIVE";
+    StatusEnum["TESTING"] = "TESTING";
+    StatusEnum["PHASE_OUT"] = "PHASE_OUT";
+    StatusEnum["INACTIVE"] = "INACTIVE";
+})(StatusEnum || (StatusEnum = {}));
+export const InitialState = [];
+export const productsSlice = createSlice({
+    name: 'products',
+    initialState: InitialState,
+    reducers: {
+        setProducts: (state, action) => ({
+            ...state,
+            ...action.payload,
+        }),
+        resetProducts: () => InitialState,
+    },
+});
+// Actions
+export const { setProducts, resetProducts } = productsSlice.actions;
+export const productsReducer = productsSlice.reducer;
+// Selectors
+export const selectProducts = (state) => state.products;

package/lib/redux/slices/userSlice.d.ts

@@ -0,0 +1,36 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { User } from '../../model/User';
+interface UserState {
+    logged?: User;
+}
+export declare const userSlice: import("@reduxjs/toolkit").Slice<UserState, {
+    setLoggedUser: (state: {
+        logged?: {
+            uid: string;
+            taxCode?: string | undefined;
+            name?: string | undefined;
+            surname?: string | undefined;
+            email?: string | undefined;
+            iss?: string | undefined;
+        } | undefined;
+    }, action: PayloadAction<User>) => void;
+}, "user", "user", import("@reduxjs/toolkit").SliceSelectors<UserState>>;
+export declare const userActions: import("@reduxjs/toolkit").CaseReducerActions<{
+    setLoggedUser: (state: {
+        logged?: {
+            uid: string;
+            taxCode?: string | undefined;
+            name?: string | undefined;
+            surname?: string | undefined;
+            email?: string | undefined;
+            iss?: string | undefined;
+        } | undefined;
+    }, action: PayloadAction<User>) => void;
+}, "user">;
+export declare const userReducer: import("redux").Reducer<UserState>;
+export declare const userSelectors: {
+    selectLoggedUser: (state: {
+        user: UserState;
+    }) => User | undefined;
+};
+export {};

package/lib/redux/slices/userSlice.js

@@ -0,0 +1,17 @@
+import { createSlice } from '@reduxjs/toolkit';
+const initialState = {};
+/* eslint-disable functional/immutable-data */
+export const userSlice = createSlice({
+    name: 'user',
+    initialState,
+    reducers: {
+        setLoggedUser: (state, action) => {
+            state.logged = action.payload;
+        },
+    },
+});
+export const userActions = userSlice.actions;
+export const userReducer = userSlice.reducer;
+export const userSelectors = {
+    selectLoggedUser: (state) => state.user.logged,
+};

package/{services → lib/services}/analyticsService.d.ts

@@ -9,4 +9,5 @@ export declare const trackAppError: (error: AppError) => void;
  * @property properties: the additional payload sent with the event
  * @property callback: an action taken when the track has completed (If the action taken immediately after the track is an exit action from the application, it's better to use this callback to perform the exit, in order to give to mixPanel the time to send the event)
  */
-export declare const trackEvent: (event_name: string, properties?: any, callback?: (() => void) | undefined) => void;
+export declare const trackEvent: (event_name: string, properties?: any, callback?: () => void) => void;
+export declare const registerSuperProperty: (properties: Record<string, any>) => void;

package/{services → lib/services}/analyticsService.js

@@ -1,49 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trackEvent = exports.trackAppError = exports.initAnalytics = void 0;
-const tslib_1 = require("tslib");
-const mixpanel_browser_1 = tslib_1.__importDefault(require("mixpanel-browser"));
-const env_1 = require("../config/env");
+import mixpanel from 'mixpanel-browser';
+import { CONFIG } from '../config/env';
 /** To call in order to start the analytics service, otherwise no event will be sent */
-const initAnalytics = () => {
-    if (env_1.CONFIG.ANALYTCS.ENABLE) {
+export const initAnalytics = () => {
+    if (CONFIG.ANALYTCS.ENABLE) {
         // eslint-disable-next-line functional/immutable-data
         window.initMixPanel = true;
-        if (env_1.CONFIG.ANALYTCS.MOCK) {
+        if (CONFIG.ANALYTCS.MOCK) {
             // eslint-disable-next-line no-console
             console.log('Mixpanel events mock on console log.');
         }
         else {
-            mixpanel_browser_1.default.init(env_1.CONFIG.ANALYTCS.TOKEN, {
-                api_host: env_1.CONFIG.ANALYTCS.API_HOST,
-                persistence: env_1.CONFIG.ANALYTCS.PERSISTENCE,
-                ip: env_1.CONFIG.ANALYTCS.LOG_IP,
-                property_blacklist: env_1.CONFIG.ANALYTCS.PROPERTY_BLACKLIST,
-                debug: env_1.CONFIG.ANALYTCS.DEBUG,
+            mixpanel.init(CONFIG.ANALYTCS.TOKEN, {
+                api_host: CONFIG.ANALYTCS.API_HOST,
+                persistence: CONFIG.ANALYTCS.PERSISTENCE,
+                ip: CONFIG.ANALYTCS.LOG_IP,
+                property_blacklist: CONFIG.ANALYTCS.PROPERTY_BLACKLIST,
+                debug: CONFIG.ANALYTCS.DEBUG,
             });
         }
     }
 };
-exports.initAnalytics = initAnalytics;
 /** To notify an error through the analytics tool */
-const trackAppError = (error) => {
-    if (env_1.CONFIG.ANALYTCS.ENABLE && window.initMixPanel) {
-        (0, exports.trackEvent)('GENERIC_ERROR', error);
+export const trackAppError = (error) => {
+    if (CONFIG.ANALYTCS.ENABLE && window.initMixPanel) {
+        trackEvent('GENERIC_ERROR', error);
     }
     else {
         console.error(error);
     }
 };
-exports.trackAppError = trackAppError;
 /**
  * To notify an event through the analytics tool:
  * @property event_name: the name of the event
  * @property properties: the additional payload sent with the event
  * @property callback: an action taken when the track has completed (If the action taken immediately after the track is an exit action from the application, it's better to use this callback to perform the exit, in order to give to mixPanel the time to send the event)
  */
-const trackEvent = (event_name, properties, callback) => {
-    if (env_1.CONFIG.ANALYTCS.ENABLE && window.initMixPanel) {
-        if (env_1.CONFIG.ANALYTCS.MOCK) {
+export const trackEvent = (event_name, properties, callback) => {
+    if (CONFIG.ANALYTCS.ENABLE && window.initMixPanel) {
+        if (CONFIG.ANALYTCS.MOCK) {
             // eslint-disable-next-line no-console
             console.log(event_name, properties);
             if (callback) {
@@ -60,7 +54,6 @@ const trackEvent = (event_name, properties, callback) => {
         }
     }
 };
-exports.trackEvent = trackEvent;
 const trackEventThroughAnalyticTool = (event_name, properties, callback) => {
     // eslint-disable-next-line functional/no-let
     let called = false;
@@ -76,10 +69,10 @@ const trackEventThroughAnalyticTool = (event_name, properties, callback) => {
         }
         : undefined;
     try {
-        mixpanel_browser_1.default.track(event_name, {
-            ...env_1.CONFIG.ANALYTCS.ADDITIONAL_PROPERTIES,
+        mixpanel.track(event_name, {
+            ...CONFIG.ANALYTCS.ADDITIONAL_PROPERTIES,
             ...properties,
-            ...env_1.CONFIG.ANALYTCS.ADDITIONAL_PROPERTIES_IMPORTANT,
+            ...CONFIG.ANALYTCS.ADDITIONAL_PROPERTIES_IMPORTANT,
         }, wrappedCallback ? { send_immediately: true } : undefined, wrappedCallback);
     }
     catch (reason) {
@@ -91,4 +84,14 @@ const trackEventThroughAnalyticTool = (event_name, properties, callback) => {
         }
     }
 };
-//# sourceMappingURL=analyticsService.js.map
+export const registerSuperProperty = (properties) => {
+    if (CONFIG.ANALYTCS.ENABLE && window.initMixPanel) {
+        if (CONFIG.ANALYTCS.MOCK) {
+            // eslint-disable-next-line no-console
+            console.log('registerSuperProperty', properties);
+        }
+        else {
+            mixpanel.register(properties);
+        }
+    }
+};

package/{services → lib/services}/assistanceService.d.ts

@@ -1 +1 @@
-export declare const buildAssistanceURI: (assistanceEmail?: string | undefined) => string;
+export declare const buildAssistanceURI: (assistanceEmail?: string) => string;

package/lib/services/assistanceService.js

@@ -0,0 +1,14 @@
+import isEmpty from 'lodash/isEmpty';
+import { CONFIG } from '../config/env';
+import { storageUserOps } from '../utils/storage';
+import { trackEvent } from './analyticsService';
+export const buildAssistanceURI = (assistanceEmail) => {
+    const sessionStorageUser = storageUserOps.read();
+    if (isEmpty(sessionStorageUser)) {
+        trackEvent('CUSTOMER_CARE_MAILTO');
+        return `mailto:${assistanceEmail}`;
+    }
+    else {
+        return CONFIG.URL_FE.ASSISTANCE;
+    }
+};

package/lib/services/errorService.js

@@ -0,0 +1,8 @@
+import { trackAppError } from './analyticsService';
+export const handleErrors = (errors) => {
+    errors
+        .filter((e) => e.toNotify)
+        .forEach((e) => {
+        trackAppError(e);
+    });
+};

package/{utils → lib/utils}/api-utils.d.ts

@@ -1,16 +1,16 @@
 import { ApiRequestType, IResponseType, TypeofApiResponse } from '@pagopa/ts-commons/lib/requests';
-import * as t from 'io-ts';
 import { EnhancedStore } from '@reduxjs/toolkit';
+import * as t from 'io-ts';
 /** To show an error popup to inform of the not valid session */
 export declare const onRedirectToLogin: (store: EnhancedStore) => {
     payload: import("../model/AppError").AppError;
     type: "appState/addError";
 };
 /** Return the implementation of fetch configured with a timeout */
-export declare const buildFetchApi: (timeoutMs?: number) => (input: RequestInfo | URL, init?: RequestInit | undefined) => Promise<Response>;
+export declare const buildFetchApi: (timeoutMs?: number) => ((input: RequestInfo | URL, init?: RequestInit | undefined) => Promise<Response>);
 /** Extract the response of a @pagopa/openapi-codegen-ts generated client rest invocation having status code successHttpStatus.
 If notValidTokenHttpStatus is not null and the returned status is equal to notValidTokenHttpStatus, it will call the onRedirectToLogin function and will schedule the redirect towards logout path.
 If notAuthorizedTokenHttpStatus is  not null and the returned status is equal to notAuthorizedTokenHttpStatus, it will throw an Error with message "Operation not allowed".
 If emptyResponseHttpStatus is  not null and the returned status is equal to emptyResponseHttpStatus, it will return a promise that resolve to null value.
 Other statuses will return will throw a generic error. */
-export declare const extractResponse: <R>(response: t.Validation<TypeofApiResponse<ApiRequestType<any, any, any, IResponseType<any, any, any>>>>, successHttpStatus: number, onRedirectToLogin: () => void, notValidTokenHttpStatus?: number | null, notAuthorizedTokenHttpStatus?: number | null, emptyResponseHttpStatus?: number | null) => Promise<R>;
+export declare const extractResponse: <R>(response: t.Validation<TypeofApiResponse<ApiRequestType<any, any, any, IResponseType<any, any, any>>>>, successHttpStatus: number | Array<number>, onRedirectToLogin: () => void, notValidTokenHttpStatus?: number | null, notAuthorizedTokenHttpStatus?: number | null, emptyResponseHttpStatus?: number | null) => Promise<R>;