@smess/networking 1.0.1

package/dist/core/rx.http.service.d.ts

@@ -0,0 +1,51 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from '../utils/networking-import';
+import type { AxiosInterceptorManager } from 'axios';
+import { AxiosObservable } from './axios.observable';
+export interface Axiosable {
+    request<T = any>(config: AxiosRequestConfig): AxiosObservable<T>;
+    get<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    head<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    patch<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    delete<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+}
+declare class HttpService implements Axiosable {
+    private axiosInstance;
+    static defaults: Omit<import("axios").AxiosDefaults<any>, "headers"> & {
+        headers: import("axios").HeadersDefaults & {
+            [key: string]: import("axios").AxiosHeaderValue;
+        };
+    };
+    static interceptors: {
+        request: AxiosInterceptorManager<import("axios").InternalAxiosRequestConfig>;
+        response: AxiosInterceptorManager<AxiosResponse>;
+    };
+    constructor(axiosInstance: AxiosInstance);
+    get defaults(): Omit<import("axios").AxiosDefaults<any>, "headers"> & {
+        headers: import("axios").HeadersDefaults & {
+            [key: string]: import("axios").AxiosHeaderValue;
+        };
+    };
+    get interceptors(): {
+        request: AxiosInterceptorManager<import("axios").InternalAxiosRequestConfig>;
+        response: AxiosInterceptorManager<AxiosResponse>;
+    };
+    static request<T = any>(config: AxiosRequestConfig): AxiosObservable<T>;
+    static get<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static patch<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static delete<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static head<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static create(config: AxiosRequestConfig): HttpService;
+    request<T = any>(config: AxiosRequestConfig): AxiosObservable<T>;
+    get<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    patch<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    delete<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    head<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+}
+export default HttpService;
+export { HttpService };

package/dist/core/rx.http.service.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpService = void 0;
+const networking_import_1 = require("../utils/networking-import");
+const axios_observable_1 = require("./axios.observable");
+class HttpService {
+    constructor(axiosInstance) {
+        this.axiosInstance = axiosInstance;
+    }
+    get defaults() {
+        return this.axiosInstance.defaults;
+    }
+    get interceptors() {
+        return this.axiosInstance.interceptors;
+    }
+    // Static methods
+    static request(config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.request, [config]);
+    }
+    static get(url, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.get, [url, config]);
+    }
+    static post(url, data, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.post, [url, data, config]);
+    }
+    static put(url, data, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.put, [url, data, config]);
+    }
+    static patch(url, data, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.patch, [url, data, config]);
+    }
+    static delete(url, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.delete, [url, config]);
+    }
+    static head(url, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.head, [url, config]);
+    }
+    static create(config) {
+        return new HttpService(networking_import_1.axios.create(config));
+    }
+    // Instance methods
+    request(config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.request, [config]);
+    }
+    get(url, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.get, [url, config]);
+    }
+    post(url, data, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.post, [url, data, config]);
+    }
+    put(url, data, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.put, [url, data, config]);
+    }
+    patch(url, data, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.patch, [url, data, config]);
+    }
+    delete(url, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.delete, [url, config]);
+    }
+    head(url, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.head, [url, config]);
+    }
+}
+exports.HttpService = HttpService;
+HttpService.defaults = networking_import_1.axios.defaults;
+HttpService.interceptors = networking_import_1.axios.interceptors;
+exports.default = HttpService;

package/dist/core/user.service.d.ts

@@ -0,0 +1,15 @@
+import { BaseProvider } from './base.provider';
+import { BaseServiceWrapper } from './base.service.wrapper';
+export interface User {
+    id: number;
+    name: string;
+    email: string;
+}
+export declare class UserProvider extends BaseProvider {
+    constructor(userId?: number);
+}
+export declare class UserService extends BaseServiceWrapper<UserProvider> {
+    constructor(userId?: number);
+    fetchUserById(id: number): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<User>>;
+    fetchAllUsers(): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<User[]>>;
+}

package/dist/core/user.service.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserService = exports.UserProvider = void 0;
+const base_provider_1 = require("./base.provider");
+const base_service_wrapper_1 = require("./base.service.wrapper");
+// UserProvider implements ProviderType for user endpoints
+class UserProvider extends base_provider_1.BaseProvider {
+    constructor(userId) {
+        super({
+            baseURL: 'https://jsonplaceholder.typicode.com',
+            path: userId ? `/users/${userId}` : '/users',
+            method: 'GET',
+            headers: {},
+            getPath: () => (userId ? `/users/${userId}` : '/users'),
+        });
+    }
+}
+exports.UserProvider = UserProvider;
+// UserService provides high-level methods for user API
+class UserService extends base_service_wrapper_1.BaseServiceWrapper {
+    constructor(userId) {
+        super(new UserProvider(userId));
+    }
+    // Fetch a user by ID
+    fetchUserById(id) {
+        this.provider = new UserProvider(id);
+        return this.request();
+    }
+    // Fetch all users
+    fetchAllUsers() {
+        this.provider = new UserProvider();
+        return this.request();
+    }
+}
+exports.UserService = UserService;
+// Example usage:
+// setNetworkingConfig({ baseUrl: 'https://jsonplaceholder.typicode.com', isProd: false });
+// const userService = new UserService();
+// userService.fetchUserById(1).subscribe(result => console.log(result)); 

package/dist/core/user.service.test.d.ts

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

package/dist/core/user.service.test.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const user_service_1 = require("./user.service");
+const types_1 = require("../types/types");
+const rxjs_1 = require("rxjs");
+jest.mock('./base.service.wrapper', () => {
+    const actual = jest.requireActual('./base.service.wrapper');
+    return Object.assign(Object.assign({}, actual), { BaseServiceWrapper: class {
+            constructor() {
+                this.request = jest.fn((payload) => {
+                    if (payload === 'error') {
+                        return (0, rxjs_1.throwError)(() => new Error('Test error'));
+                    }
+                    return (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded({ id: 1, name: 'Test', email: 'test@example.com' }));
+                });
+            }
+        } });
+});
+describe('UserService', () => {
+    it('fetchUserById should return user (success)', done => {
+        const service = new user_service_1.UserService();
+        service.fetchUserById(1).subscribe(result => {
+            expect(result.response).toEqual({ id: 1, name: 'Test', email: 'test@example.com' });
+            done();
+        });
+    });
+    it('fetchAllUsers should return users (success)', done => {
+        const service = new user_service_1.UserService();
+        service.fetchAllUsers().subscribe(result => {
+            expect(result.response).toEqual({ id: 1, name: 'Test', email: 'test@example.com' });
+            done();
+        });
+    });
+    it('request should handle error', done => {
+        const service = new user_service_1.UserService();
+        service.request = jest.fn(() => (0, rxjs_1.throwError)(() => new Error('Test error')));
+        service.request('error').subscribe({
+            error: err => {
+                expect(err).toBeInstanceOf(Error);
+                expect(err.message).toBe('Test error');
+                done();
+            },
+        });
+    });
+});

package/dist/scripts/real-test.d.ts

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

package/dist/scripts/real-test.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const user_service_js_1 = require("../src/domain/user.service.js");
+const rxjs_1 = require("rxjs");
+const axios_1 = __importDefault(require("axios"));
+async function testUserService() {
+    const config = {
+        baseUrl: 'https://jsonplaceholder.typicode.com',
+        isProd: false,
+    };
+    const userService = new user_service_js_1.UserService(config);
+    let emitted = false;
+    try {
+        const obs$ = userService.fetchUserById(1).pipe((0, rxjs_1.timeout)({ first: 10000 }), (0, rxjs_1.catchError)(err => {
+            console.error('❌ UserService observable error:', err);
+            return (0, rxjs_1.of)(undefined);
+        }));
+        await new Promise((resolve, reject) => {
+            obs$.subscribe({
+                next: (val) => {
+                    emitted = true;
+                    console.log('UserService emission:', val);
+                    if (val && val.hasSuccess && val.response) {
+                        console.log('✅ UserService real API test succeeded:', val.response);
+                        resolve(undefined);
+                    }
+                    else if (val && val.hasFailed) {
+                        console.error('❌ UserService real API test failed:', val.alertModel || val);
+                        reject(new Error('UserService failed'));
+                    }
+                },
+                error: (err) => {
+                    console.error('❌ UserService observable error:', err);
+                    reject(err);
+                },
+                complete: () => {
+                    if (!emitted) {
+                        console.error('❌ UserService observable completed without emission');
+                        reject(new Error('No emission'));
+                    }
+                }
+            });
+        });
+    }
+    catch (err) {
+        console.error('❌ UserService test error:', err);
+        process.exit(2);
+    }
+}
+async function testAxiosDirect() {
+    try {
+        const response = await axios_1.default.get('https://jsonplaceholder.typicode.com/users/1');
+        if (response && response.data && response.data.id === 1) {
+            console.log('✅ Direct axios test succeeded:', response.data);
+        }
+        else {
+            console.error('❌ Direct axios test failed:', response.data);
+            process.exit(3);
+        }
+    }
+    catch (err) {
+        console.error('❌ Direct axios test error:', err);
+        process.exit(4);
+    }
+}
+(async () => {
+    await testAxiosDirect();
+    await testUserService();
+    console.log('🎉 All real API tests passed!');
+    process.exit(0);
+})();

package/dist/services/logger.service.d.ts

@@ -0,0 +1,31 @@
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    NONE = 4
+}
+export interface LogEntry {
+    level: LogLevel;
+    message: string;
+    data?: any;
+    timestamp: number;
+    context?: string;
+}
+export declare class LoggerService {
+    private currentLevel;
+    private logs;
+    private maxLogs;
+    setLogLevel(level: LogLevel): void;
+    private shouldLog;
+    private formatMessage;
+    private getEmojiForLevel;
+    private log;
+    debug(message: string, data?: any, context?: string): void;
+    info(message: string, data?: any, context?: string): void;
+    warn(message: string, data?: any, context?: string): void;
+    error(message: string, data?: any, context?: string): void;
+    getLogs(): LogEntry[];
+    clearLogs(): void;
+}
+export declare const $logger: LoggerService;

package/dist/services/logger.service.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$logger = exports.LoggerService = exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["NONE"] = 4] = "NONE";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+class LoggerService {
+    constructor() {
+        this.currentLevel = LogLevel.DEBUG;
+        this.logs = [];
+        this.maxLogs = 1000;
+    }
+    setLogLevel(level) {
+        this.currentLevel = level;
+    }
+    shouldLog(level) {
+        return level >= this.currentLevel;
+    }
+    formatMessage(level, message, context) {
+        const emoji = this.getEmojiForLevel(level);
+        const levelName = LogLevel[level];
+        const contextStr = context ? ` [${context}]` : '';
+        return `${emoji} ${levelName}${contextStr}: ${message}`;
+    }
+    getEmojiForLevel(level) {
+        switch (level) {
+            case LogLevel.DEBUG:
+                return '🔍';
+            case LogLevel.INFO:
+                return 'ℹ️';
+            case LogLevel.WARN:
+                return '⚠️';
+            case LogLevel.ERROR:
+                return '❌';
+            default:
+                return '📝';
+        }
+    }
+    log(level, message, data, context) {
+        if (!this.shouldLog(level))
+            return;
+        const logEntry = {
+            level,
+            message,
+            data,
+            timestamp: Date.now(),
+            context
+        };
+        // Store log entry
+        this.logs.push(logEntry);
+        if (this.logs.length > this.maxLogs) {
+            this.logs.shift();
+        }
+        // Console output
+        const formattedMessage = this.formatMessage(level, message, context);
+        switch (level) {
+            case LogLevel.DEBUG:
+                console.debug(formattedMessage, data || '');
+                break;
+            case LogLevel.INFO:
+                console.info(formattedMessage, data || '');
+                break;
+            case LogLevel.WARN:
+                console.warn(formattedMessage, data || '');
+                break;
+            case LogLevel.ERROR:
+                console.error(formattedMessage, data || '');
+                break;
+        }
+    }
+    debug(message, data, context) {
+        this.log(LogLevel.DEBUG, message, data, context);
+    }
+    info(message, data, context) {
+        this.log(LogLevel.INFO, message, data, context);
+    }
+    warn(message, data, context) {
+        this.log(LogLevel.WARN, message, data, context);
+    }
+    error(message, data, context) {
+        this.log(LogLevel.ERROR, message, data, context);
+    }
+    getLogs() {
+        return [...this.logs];
+    }
+    clearLogs() {
+        this.logs = [];
+    }
+}
+exports.LoggerService = LoggerService;
+// Export singleton instance
+exports.$logger = new LoggerService();

package/dist/services/logger.service.test.d.ts

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

package/dist/services/logger.service.test.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_service_1 = require("./logger.service");
+describe('LoggerService', () => {
+    beforeEach(() => {
+        logger_service_1.$logger.clearLogs();
+        logger_service_1.$logger.setLogLevel(logger_service_1.LogLevel.DEBUG);
+    });
+    it('should log info', () => {
+        logger_service_1.$logger.info('info message', { foo: 1 }, 'test');
+        const logs = logger_service_1.$logger.getLogs();
+        expect(logs[0].level).toBe(logger_service_1.LogLevel.INFO);
+        expect(logs[0].message).toBe('info message');
+        expect(logs[0].data).toEqual({ foo: 1 });
+        expect(logs[0].context).toBe('test');
+    });
+    it('should log warn and error', () => {
+        logger_service_1.$logger.warn('warn message');
+        logger_service_1.$logger.error('error message', { bar: 2 });
+        const logs = logger_service_1.$logger.getLogs();
+        expect(logs[0].level).toBe(logger_service_1.LogLevel.WARN);
+        expect(logs[1].level).toBe(logger_service_1.LogLevel.ERROR);
+        expect(logs[1].data).toEqual({ bar: 2 });
+    });
+    it('should respect log level', () => {
+        logger_service_1.$logger.setLogLevel(logger_service_1.LogLevel.ERROR);
+        logger_service_1.$logger.info('should not log');
+        logger_service_1.$logger.error('should log');
+        const logs = logger_service_1.$logger.getLogs();
+        expect(logs.length).toBe(1);
+        expect(logs[0].level).toBe(logger_service_1.LogLevel.ERROR);
+    });
+});

package/dist/services/smess.service.d.ts

@@ -0,0 +1,29 @@
+import { HeaderType, NetworkingUIEventWrapped, ProviderType } from '../types/types';
+import { Observable } from '../utils/rxjs-import';
+export declare enum SMESSHeader {
+    ContentType = "Content-Type",
+    Authorization = "Authorization",
+    Accept = "Accept",
+    ApiKey = "X-Api-Key",
+    ClientId = "X-Client-Id"
+}
+export declare enum ContentType {
+    Json = "application/json",
+    FormURLEncoded = "application/x-www-form-urlencoded"
+}
+export declare enum Accept {
+    V1 = "application/json",
+    V2 = "application/vnd.smess.v2+json",
+    V3 = "application/vnd.smess.v3+json",
+    V4 = "application/vnd.smess.v4+json"
+}
+export declare class SmessService<T extends ProviderType> {
+    private httpService;
+    private target;
+    constructor(target: T);
+    static getHeaders(version: Accept, authorization?: string | null, options?: HeaderType): Record<SMESSHeader, any>;
+    private static commonHeaders;
+    request<R = any>(request?: any, mockResponse?: R, ...queryParams: any[]): Observable<NetworkingUIEventWrapped<R>>;
+    private transformAxiosError;
+    private transformAxiosResponse;
+}

package/dist/services/smess.service.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmessService = exports.Accept = exports.ContentType = exports.SMESSHeader = void 0;
+const types_1 = require("../types/types");
+const rxjs_import_1 = require("../utils/rxjs-import");
+const rx_http_service_1 = __importDefault(require("../core/rx.http.service"));
+const logger_service_1 = require("./logger.service");
+// import { LOG_SERVICES_CONTEXT } from '@/services';
+var SMESSHeader;
+(function (SMESSHeader) {
+    SMESSHeader["ContentType"] = "Content-Type";
+    SMESSHeader["Authorization"] = "Authorization";
+    SMESSHeader["Accept"] = "Accept";
+    SMESSHeader["ApiKey"] = "X-Api-Key";
+    SMESSHeader["ClientId"] = "X-Client-Id";
+})(SMESSHeader || (exports.SMESSHeader = SMESSHeader = {}));
+var ContentType;
+(function (ContentType) {
+    ContentType["Json"] = "application/json";
+    ContentType["FormURLEncoded"] = "application/x-www-form-urlencoded";
+})(ContentType || (exports.ContentType = ContentType = {}));
+var Accept;
+(function (Accept) {
+    Accept["V1"] = "application/json";
+    Accept["V2"] = "application/vnd.smess.v2+json";
+    Accept["V3"] = "application/vnd.smess.v3+json";
+    Accept["V4"] = "application/vnd.smess.v4+json";
+})(Accept || (exports.Accept = Accept = {}));
+const isProduction = typeof process !== 'undefined' && process.env.NODE_ENV === 'production';
+class SmessService {
+    constructor(target) {
+        this.target = target;
+        // Set default headers
+        logger_service_1.$logger.info('SmessService initialized', {
+            target: this.target,
+            baseURL: this.target.baseURL,
+            method: this.target.method,
+            headers: this.target.headers,
+        }, 'SmessService');
+        this.httpService = rx_http_service_1.default.create({
+            baseURL: this.target.baseURL,
+            headers: this.target.headers,
+            method: this.target.method,
+        });
+        this.httpService.interceptors.response.use((response) => response, async (error) => {
+            var _a;
+            const originalRequest = error.config;
+            if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 401 && !originalRequest._retry) {
+                originalRequest._retry = true;
+                logger_service_1.$logger.info('SmessService constructor - 401 retry', originalRequest, 'SmessService');
+                // Implement token refresh logic here
+                // Then retry the original request
+                // return httpService.request(originalRequest);
+            }
+            return Promise.reject(error);
+        });
+    }
+    static getHeaders(version, authorization = null, options) {
+        const headers = this.commonHeaders(version, options);
+        if (authorization) {
+            headers['Authorization'] = authorization;
+        }
+        return headers;
+    }
+    static commonHeaders(version, options) {
+        const { shouldAddClientIdHeader = true, } = options !== null && options !== void 0 ? options : {};
+        const headers = {
+            Accept: version,
+            Authorization: '',
+            'Content-Type': ContentType.Json,
+            'X-Api-Key': '',
+            'X-Client-Id': '',
+        };
+        if (shouldAddClientIdHeader) {
+            // headers[SMESSHeader.ClientId] = clientId; // Removed clientId usage
+        }
+        return headers;
+    }
+    // MARK: - Public
+    request(request, mockResponse, ...queryParams) {
+        if (mockResponse !== undefined) {
+            return (0, rxjs_import_1.of)(types_1.NetworkingUIEventWrapped.succeeded(mockResponse));
+        }
+        const url = queryParams.length
+            ? this.target.getPath(queryParams)
+            : this.target.path;
+        const config = { url };
+        let observable;
+        if (this.target.method === 'GET') {
+            if (request) {
+                config.data = request;
+                config.params = request;
+            }
+            // Note: HttpService.get expects (url, config)
+            observable = this.httpService.get(url, config);
+        }
+        else if (this.target.method === 'POST') {
+            // HttpService.post expects (url, data, config)
+            observable = this.httpService.post(url, request, config);
+        }
+        else if (this.target.method === 'PATCH') {
+            observable = this.httpService.patch(url, request, config);
+        }
+        else if (this.target.method === 'PUT') {
+            observable = this.httpService.put(url, request, config);
+        }
+        else {
+            observable = this.httpService.request(config);
+        }
+        return observable.pipe((0, rxjs_import_1.catchError)((error) => this.transformAxiosError(error, mockResponse)), (0, rxjs_import_1.mergeMap)((data) => this.transformAxiosResponse(data)), (0, rxjs_import_1.startWith)(types_1.NetworkingUIEventWrapped.waiting()));
+    }
+    // MARK: - Private
+    transformAxiosError(error, mockResponse) {
+        logger_service_1.$logger.error('transformAxiosError', error, 'SmessService');
+        const message = error.message;
+        const response = error.response;
+        const httpErrorCode = response ? response.status : 0;
+        const title = response === null || response === void 0 ? void 0 : response.statusText;
+        const alertModel = new types_1.AlertModel(message, httpErrorCode, true, title, response === null || response === void 0 ? void 0 : response.data, [types_1.AlertButtonModel.buttonYes()]);
+        if (mockResponse) {
+            return (0, rxjs_import_1.of)(types_1.NetworkingUIEventWrapped.succeeded(mockResponse));
+        }
+        return (0, rxjs_import_1.of)(types_1.NetworkingUIEventWrapped.failed(alertModel));
+    }
+    transformAxiosResponse(response) {
+        logger_service_1.$logger.info('transformAxiosResponse', response, 'SmessService');
+        if (response instanceof types_1.NetworkingUIEventWrapped) {
+            return (0, rxjs_import_1.of)(response);
+        }
+        return (0, rxjs_import_1.of)(types_1.NetworkingUIEventWrapped.succeeded(response.data));
+    }
+}
+exports.SmessService = SmessService;

package/dist/services/smess.service.test.d.ts

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