@smess/networking 1.0.1

package/dist/src/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?: unknown;
+    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?: unknown, context?: string): void;
+    info(message: string, data?: unknown, context?: string): void;
+    warn(message: string, data?: unknown, context?: string): void;
+    error(message: string, data?: unknown, context?: string): void;
+    getLogs(): LogEntry[];
+    clearLogs(): void;
+}
+export declare const $logger: LoggerService;

package/dist/src/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/src/services/logger.service.test.d.ts

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

package/dist/src/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/src/types/types.d.ts

@@ -0,0 +1,95 @@
+export type CallbackHandler = () => void;
+interface AlertModelable {
+    isUnauthenticated: boolean;
+    isNetworkingError: boolean;
+}
+interface AlertButtonModelable {
+    title: string;
+    handler?: CallbackHandler;
+}
+export declare class AlertButtonModel implements AlertButtonModelable {
+    title: string;
+    handler?: CallbackHandler | undefined;
+    constructor(title: string, handler?: CallbackHandler | undefined);
+    static buttonYes(handler?: CallbackHandler): AlertButtonModelable;
+    static buttonNo(handler?: CallbackHandler): AlertButtonModelable;
+}
+export declare class AlertModel implements AlertModelable {
+    message: string;
+    httpErrorCode: number;
+    isDisplayable: boolean;
+    title?: string | undefined;
+    data?: unknown | undefined;
+    buttons?: AlertButtonModelable[] | undefined;
+    constructor(message: string, httpErrorCode: number, isDisplayable?: boolean, title?: string | undefined, data?: unknown | undefined, buttons?: AlertButtonModelable[] | undefined);
+    get isUnauthenticated(): boolean;
+    get isNetworkingError(): boolean;
+    static default(): AlertModel;
+}
+export declare class ValidationErrorMessage {
+    message: string;
+    constructor(message: string);
+}
+export type NetworkingFailed = {
+    alertModel: AlertModel;
+};
+export type NetworkingSucceeded<ResponseType> = {
+    responseBody: ResponseType;
+};
+export declare enum NetworkingUIEvent {
+    waiting = "waiting",
+    succeeded = "succeeded",
+    failed = "failed"
+}
+export declare class NetworkingUIEventWrapped<JSONResponse> {
+    private event;
+    private succeeded?;
+    private failed?;
+    constructor(event: NetworkingUIEvent, succeeded?: NetworkingSucceeded<JSONResponse> | undefined, failed?: NetworkingFailed | undefined);
+    get response(): JSONResponse | null;
+    get alertModel(): AlertModel | null;
+    get isWaiting(): boolean;
+    get hasSuccess(): boolean;
+    get hasFailed(): boolean;
+    get isUnauthenticated(): boolean;
+    static waiting<JSONResponse>(): NetworkingUIEventWrapped<JSONResponse>;
+    static succeeded<JSONResponse>(data: JSONResponse): NetworkingUIEventWrapped<JSONResponse>;
+    static failed<JSONResponse>(alertModel: AlertModel): NetworkingUIEventWrapped<JSONResponse>;
+}
+export interface ProviderType {
+    baseURL: string;
+    path: string;
+    method: string;
+    headers: Record<string, string | undefined>;
+    getPath(...queryParams: unknown[]): string;
+}
+export interface ProviderTypeMockable {
+    shouldUseMockData: boolean;
+}
+export interface HeaderType {
+    shouldAddEncryptionHeader?: boolean;
+    shouldAddClientIdHeader?: boolean;
+}
+export interface HttpResponse {
+    data: unknown;
+}
+export interface ServerValidationErrorMessage {
+    message: string;
+    parameters?: {
+        error_code?: string;
+        field?: string;
+        [key: string]: unknown;
+    };
+}
+export interface ServerErrorResponse {
+    errors?: {
+        [field: string]: ServerValidationErrorMessage[];
+    };
+}
+export interface NetworkingConfig {
+    baseUrl: string;
+    isProd: boolean;
+    clientId?: string;
+    apiKey?: string;
+}
+export {};

package/dist/src/types/types.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkingUIEventWrapped = exports.NetworkingUIEvent = exports.ValidationErrorMessage = exports.AlertModel = exports.AlertButtonModel = void 0;
+class AlertButtonModel {
+    constructor(title, handler) {
+        this.title = title;
+        this.handler = handler;
+    }
+    static buttonYes(handler) {
+        return new AlertButtonModel('Yes', handler);
+    }
+    static buttonNo(handler) {
+        return new AlertButtonModel('No', handler);
+    }
+}
+exports.AlertButtonModel = AlertButtonModel;
+class AlertModel {
+    constructor(message, httpErrorCode, isDisplayable = false, title, data, buttons) {
+        this.message = message;
+        this.httpErrorCode = httpErrorCode;
+        this.isDisplayable = isDisplayable;
+        this.title = title;
+        this.data = data;
+        this.buttons = buttons;
+    }
+    get isUnauthenticated() {
+        return this.httpErrorCode == 401;
+    }
+    get isNetworkingError() {
+        return this.httpErrorCode == 0;
+    }
+    static default() {
+        return new AlertModel('Generic Error', 0, true, '', null, [
+            AlertButtonModel.buttonYes(),
+        ]);
+    }
+}
+exports.AlertModel = AlertModel;
+class ValidationErrorMessage {
+    constructor(message) {
+        this.message = message;
+    }
+}
+exports.ValidationErrorMessage = ValidationErrorMessage;
+var NetworkingUIEvent;
+(function (NetworkingUIEvent) {
+    NetworkingUIEvent["waiting"] = "waiting";
+    NetworkingUIEvent["succeeded"] = "succeeded";
+    NetworkingUIEvent["failed"] = "failed";
+})(NetworkingUIEvent || (exports.NetworkingUIEvent = NetworkingUIEvent = {}));
+class NetworkingUIEventWrapped {
+    constructor(event, succeeded, failed) {
+        this.event = event;
+        this.succeeded = succeeded;
+        this.failed = failed;
+    }
+    get response() {
+        return this.succeeded ? this.succeeded.responseBody : null;
+    }
+    get alertModel() {
+        return this.failed ? this.failed.alertModel : null;
+    }
+    get isWaiting() {
+        return this.event == NetworkingUIEvent.waiting;
+    }
+    get hasSuccess() {
+        return this.event == NetworkingUIEvent.succeeded;
+    }
+    get hasFailed() {
+        return this.event == NetworkingUIEvent.failed;
+    }
+    get isUnauthenticated() {
+        return this.alertModel ? this.alertModel.isUnauthenticated : false;
+    }
+    static waiting() {
+        return new NetworkingUIEventWrapped(NetworkingUIEvent.waiting);
+    }
+    static succeeded(data) {
+        return new NetworkingUIEventWrapped(NetworkingUIEvent.succeeded, {
+            responseBody: data,
+        });
+    }
+    static failed(alertModel) {
+        return new NetworkingUIEventWrapped(NetworkingUIEvent.failed, undefined, {
+            alertModel: alertModel,
+        });
+    }
+}
+exports.NetworkingUIEventWrapped = NetworkingUIEventWrapped;

package/dist/src/types/types.test.d.ts

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

package/dist/src/types/types.test.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("./types");
+describe('NetworkingUIEventWrapped', () => {
+    it('should wrap succeeded response', () => {
+        const wrap = types_1.NetworkingUIEventWrapped.succeeded({ foo: 'bar' });
+        expect(wrap.response).toEqual({ foo: 'bar' });
+        expect(wrap.hasSuccess).toBe(true);
+        expect(wrap.hasFailed).toBe(false);
+        expect(wrap.isWaiting).toBe(false);
+    });
+    it('should wrap failed response and set alertModel', () => {
+        const alert = new types_1.AlertModel('err', 500, true, 'Error', { detail: 'fail' });
+        const wrap = types_1.NetworkingUIEventWrapped.failed(alert);
+        expect(wrap.response).toBeNull();
+        expect(wrap.hasSuccess).toBe(false);
+        expect(wrap.hasFailed).toBe(true);
+        expect(wrap.isWaiting).toBe(false);
+        expect(wrap.alertModel).toBe(alert);
+    });
+    it('should wrap waiting state', () => {
+        const wrap = types_1.NetworkingUIEventWrapped.waiting();
+        expect(wrap.isWaiting).toBe(true);
+        expect(wrap.hasSuccess).toBe(false);
+        expect(wrap.hasFailed).toBe(false);
+    });
+});

package/dist/src/utils/networking-import.d.ts

@@ -0,0 +1,4 @@
+export * from 'axios';
+import axios, { HttpStatusCode } from 'axios';
+export { axios, HttpStatusCode };
+export type { AxiosInstance, AxiosResponse, AxiosError, InternalAxiosRequestConfig, AxiosRequestConfig } from 'axios';

package/dist/src/utils/networking-import.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpStatusCode = exports.axios = void 0;
+__exportStar(require("axios"), exports);
+const axios_1 = __importStar(require("axios"));
+exports.axios = axios_1.default;
+Object.defineProperty(exports, "HttpStatusCode", { enumerable: true, get: function () { return axios_1.HttpStatusCode; } });

package/dist/src/utils/rxjs-import.d.ts

@@ -0,0 +1,5 @@
+import { BehaviorSubject, Observable, Subject, Subscription, Subscriber, catchError, combineLatest, concatMap, distinctUntilChanged, filter, firstValueFrom, from, fromEvent, merge, NEVER, interval, map, mergeMap, of, pipe, shareReplay, startWith, tap, timeout, retry, throwError, combineLatestWith, debounceTime, delay, takeUntil } from 'rxjs';
+export { Observable, Subject, BehaviorSubject, Subscription, Subscriber };
+export { startWith, firstValueFrom, from, fromEvent, tap, pipe, distinctUntilChanged, of, mergeMap, interval, map, concatMap, combineLatest, merge, combineLatestWith, debounceTime, delay, timeout, retry, takeUntil, NEVER };
+export { shareReplay, filter };
+export { catchError, throwError };

package/dist/src/utils/rxjs-import.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwError = exports.catchError = exports.filter = exports.shareReplay = exports.NEVER = exports.takeUntil = exports.retry = exports.timeout = exports.delay = exports.debounceTime = exports.combineLatestWith = exports.merge = exports.combineLatest = exports.concatMap = exports.map = exports.interval = exports.mergeMap = exports.of = exports.distinctUntilChanged = exports.pipe = exports.tap = exports.fromEvent = exports.from = exports.firstValueFrom = exports.startWith = exports.Subscriber = exports.Subscription = exports.BehaviorSubject = exports.Subject = exports.Observable = void 0;
+const rxjs_1 = require("rxjs");
+Object.defineProperty(exports, "BehaviorSubject", { enumerable: true, get: function () { return rxjs_1.BehaviorSubject; } });
+Object.defineProperty(exports, "Observable", { enumerable: true, get: function () { return rxjs_1.Observable; } });
+Object.defineProperty(exports, "Subject", { enumerable: true, get: function () { return rxjs_1.Subject; } });
+Object.defineProperty(exports, "Subscription", { enumerable: true, get: function () { return rxjs_1.Subscription; } });
+Object.defineProperty(exports, "Subscriber", { enumerable: true, get: function () { return rxjs_1.Subscriber; } });
+Object.defineProperty(exports, "catchError", { enumerable: true, get: function () { return rxjs_1.catchError; } });
+Object.defineProperty(exports, "combineLatest", { enumerable: true, get: function () { return rxjs_1.combineLatest; } });
+Object.defineProperty(exports, "concatMap", { enumerable: true, get: function () { return rxjs_1.concatMap; } });
+Object.defineProperty(exports, "distinctUntilChanged", { enumerable: true, get: function () { return rxjs_1.distinctUntilChanged; } });
+Object.defineProperty(exports, "filter", { enumerable: true, get: function () { return rxjs_1.filter; } });
+Object.defineProperty(exports, "firstValueFrom", { enumerable: true, get: function () { return rxjs_1.firstValueFrom; } });
+Object.defineProperty(exports, "from", { enumerable: true, get: function () { return rxjs_1.from; } });
+Object.defineProperty(exports, "fromEvent", { enumerable: true, get: function () { return rxjs_1.fromEvent; } });
+Object.defineProperty(exports, "merge", { enumerable: true, get: function () { return rxjs_1.merge; } });
+Object.defineProperty(exports, "NEVER", { enumerable: true, get: function () { return rxjs_1.NEVER; } });
+Object.defineProperty(exports, "interval", { enumerable: true, get: function () { return rxjs_1.interval; } });
+Object.defineProperty(exports, "map", { enumerable: true, get: function () { return rxjs_1.map; } });
+Object.defineProperty(exports, "mergeMap", { enumerable: true, get: function () { return rxjs_1.mergeMap; } });
+Object.defineProperty(exports, "of", { enumerable: true, get: function () { return rxjs_1.of; } });
+Object.defineProperty(exports, "pipe", { enumerable: true, get: function () { return rxjs_1.pipe; } });
+Object.defineProperty(exports, "shareReplay", { enumerable: true, get: function () { return rxjs_1.shareReplay; } });
+Object.defineProperty(exports, "startWith", { enumerable: true, get: function () { return rxjs_1.startWith; } });
+Object.defineProperty(exports, "tap", { enumerable: true, get: function () { return rxjs_1.tap; } });
+Object.defineProperty(exports, "timeout", { enumerable: true, get: function () { return rxjs_1.timeout; } });
+Object.defineProperty(exports, "retry", { enumerable: true, get: function () { return rxjs_1.retry; } });
+Object.defineProperty(exports, "throwError", { enumerable: true, get: function () { return rxjs_1.throwError; } });
+Object.defineProperty(exports, "combineLatestWith", { enumerable: true, get: function () { return rxjs_1.combineLatestWith; } });
+Object.defineProperty(exports, "debounceTime", { enumerable: true, get: function () { return rxjs_1.debounceTime; } });
+Object.defineProperty(exports, "delay", { enumerable: true, get: function () { return rxjs_1.delay; } });
+Object.defineProperty(exports, "takeUntil", { enumerable: true, get: function () { return rxjs_1.takeUntil; } });

package/dist/types/types.d.ts

@@ -0,0 +1,89 @@
+export type CallbackHandler = () => void;
+interface AlertModelable {
+    isUnauthenticated: boolean;
+    isNetworkingError: boolean;
+}
+interface AlertButtonModelable {
+    title: string;
+    handler?: CallbackHandler;
+}
+export declare class AlertButtonModel implements AlertButtonModelable {
+    title: string;
+    handler?: CallbackHandler | undefined;
+    constructor(title: string, handler?: CallbackHandler | undefined);
+    static buttonYes(handler?: CallbackHandler): AlertButtonModelable;
+    static buttonNo(handler?: CallbackHandler): AlertButtonModelable;
+}
+export declare class AlertModel implements AlertModelable {
+    message: string;
+    httpErrorCode: number;
+    isDisplayable: boolean;
+    title?: string | undefined;
+    data?: any | undefined;
+    buttons?: AlertButtonModelable[] | undefined;
+    constructor(message: string, httpErrorCode: number, isDisplayable?: boolean, title?: string | undefined, data?: any | undefined, buttons?: AlertButtonModelable[] | undefined);
+    get isUnauthenticated(): boolean;
+    get isNetworkingError(): boolean;
+    static default(): AlertModel;
+}
+export declare class ValidationErrorMessage {
+    message: string;
+    constructor(message: string);
+}
+export type NetworkingFailed = {
+    alertModel: AlertModel;
+};
+export type NetworkingSucceeded<ResponseType> = {
+    responseBody: ResponseType;
+};
+export declare enum NetworkingUIEvent {
+    waiting = "waiting",
+    succeeded = "succeeded",
+    failed = "failed"
+}
+export declare class NetworkingUIEventWrapped<JSONResponse> {
+    private event;
+    private succeeded?;
+    private failed?;
+    constructor(event: NetworkingUIEvent, succeeded?: NetworkingSucceeded<JSONResponse> | undefined, failed?: NetworkingFailed | undefined);
+    get response(): JSONResponse | null;
+    get alertModel(): AlertModel | null;
+    get isWaiting(): boolean;
+    get hasSuccess(): boolean;
+    get hasFailed(): boolean;
+    get isUnauthenticated(): boolean;
+    static waiting<JSONResponse>(): NetworkingUIEventWrapped<JSONResponse>;
+    static succeeded<JSONResponse>(data: JSONResponse): NetworkingUIEventWrapped<JSONResponse>;
+    static failed<JSONResponse>(alertModel: AlertModel): NetworkingUIEventWrapped<JSONResponse>;
+}
+export interface ProviderType {
+    baseURL: string;
+    path: string;
+    method: string;
+    headers: any;
+    getPath(...queryParams: any[]): string;
+}
+export interface ProviderTypeMockable {
+    shouldUseMockData: boolean;
+}
+export interface HeaderType {
+    shouldAddEncryptionHeader?: boolean;
+    shouldAddClientIdHeader?: boolean;
+}
+export interface HttpResponse {
+    data: unknown;
+}
+export interface ServerValidationErrorMessage {
+    message: string;
+    parameters?: {
+        error_code?: string;
+        field?: string;
+        [key: string]: any;
+    };
+}
+export interface ServerErrorResponse {
+    errors?: {
+        [field: string]: ServerValidationErrorMessage[];
+    };
+}
+export {};

package/dist/types/types.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkingUIEventWrapped = exports.NetworkingUIEvent = exports.ValidationErrorMessage = exports.AlertModel = exports.AlertButtonModel = void 0;
+class AlertButtonModel {
+    constructor(title, handler) {
+        this.title = title;
+        this.handler = handler;
+    }
+    static buttonYes(handler) {
+        return new AlertButtonModel('Yes', handler);
+    }
+    static buttonNo(handler) {
+        return new AlertButtonModel('No', handler);
+    }
+}
+exports.AlertButtonModel = AlertButtonModel;
+class AlertModel {
+    constructor(message, httpErrorCode, isDisplayable = false, title, data, buttons) {
+        this.message = message;
+        this.httpErrorCode = httpErrorCode;
+        this.isDisplayable = isDisplayable;
+        this.title = title;
+        this.data = data;
+        this.buttons = buttons;
+    }
+    get isUnauthenticated() {
+        return this.httpErrorCode == 401;
+    }
+    get isNetworkingError() {
+        return this.httpErrorCode == 0;
+    }
+    static default() {
+        return new AlertModel('Generic Error', 0, true, '', null, [
+            AlertButtonModel.buttonYes(),
+        ]);
+    }
+}
+exports.AlertModel = AlertModel;
+class ValidationErrorMessage {
+    constructor(message) {
+        this.message = message;
+    }
+}
+exports.ValidationErrorMessage = ValidationErrorMessage;
+var NetworkingUIEvent;
+(function (NetworkingUIEvent) {
+    NetworkingUIEvent["waiting"] = "waiting";
+    NetworkingUIEvent["succeeded"] = "succeeded";
+    NetworkingUIEvent["failed"] = "failed";
+})(NetworkingUIEvent || (exports.NetworkingUIEvent = NetworkingUIEvent = {}));
+class NetworkingUIEventWrapped {
+    constructor(event, succeeded, failed) {
+        this.event = event;
+        this.succeeded = succeeded;
+        this.failed = failed;
+    }
+    get response() {
+        return this.succeeded ? this.succeeded.responseBody : null;
+    }
+    get alertModel() {
+        return this.failed ? this.failed.alertModel : null;
+    }
+    get isWaiting() {
+        return this.event == NetworkingUIEvent.waiting;
+    }
+    get hasSuccess() {
+        return this.event == NetworkingUIEvent.succeeded;
+    }
+    get hasFailed() {
+        return this.event == NetworkingUIEvent.failed;
+    }
+    get isUnauthenticated() {
+        return this.alertModel ? this.alertModel.isUnauthenticated : false;
+    }
+    static waiting() {
+        return new NetworkingUIEventWrapped(NetworkingUIEvent.waiting);
+    }
+    static succeeded(data) {
+        return new NetworkingUIEventWrapped(NetworkingUIEvent.succeeded, {
+            responseBody: data,
+        });
+    }
+    static failed(alertModel) {
+        return new NetworkingUIEventWrapped(NetworkingUIEvent.failed, undefined, {
+            alertModel: alertModel,
+        });
+    }
+}
+exports.NetworkingUIEventWrapped = NetworkingUIEventWrapped;

package/dist/types/types.test.d.ts

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