@smess/networking 1.0.9 → 1.0.12

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

@@ -1,13 +1,13 @@
-import 'fake-indexeddb/auto';
-import { StoreService } from './store.service';
-import { NetworkingUIEventWrapped, AlertModel } from '../types/types';
-import { of, BehaviorSubject } from 'rxjs';
-describe('StoreService', () => {
+import "fake-indexeddb/auto";
+import { StoreService, } from "./store.service";
+import { NetworkingUIEventWrapped, AlertModel, } from "../types/types";
+import { of, BehaviorSubject } from "rxjs";
+describe("StoreService", () => {
     const config = {
-        baseUrl: 'https://api.example.com',
+        baseUrl: "https://api.example.com",
         isProd: false,
-        clientId: 'test-client-id',
-        apiKey: 'test-api-key',
+        clientId: "test-client-id",
+        apiKey: "test-api-key",
     };
     let service;
     let $authToken;
@@ -18,182 +18,258 @@ describe('StoreService', () => {
     afterEach(async () => {
         await service.clearCache();
     });
-    it('should create service instance', () => {
+    it("should create service instance", () => {
         expect(service).toBeDefined();
     });
-    it('should get store from network when no cache', async () => {
-        const response = { data: { id: '1', name: 'Store' } };
+    it("should get store from network when no cache", async () => {
+        const response = { data: { id: "1", name: "Store" } };
         const mockProvider = {
-            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+            request: jest
+                .fn()
+                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
         };
-        jest.spyOn(service, 'provider').mockReturnValue(mockProvider);
-        const result = await service.get('1').toPromise();
+        jest
+            .spyOn(service, "provider")
+            .mockReturnValue(mockProvider);
+        const result = await service.get("1").toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('should get store from cache when available', async () => {
-        const response = { data: { id: '1', name: 'Store' } };
+    it("should get store from cache when available", async () => {
+        const response = { data: { id: "1", name: "Store" } };
         // First call to populate cache
         const mockProvider1 = {
-            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+            request: jest
+                .fn()
+                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
         };
-        jest.spyOn(service, 'provider').mockReturnValue(mockProvider1);
-        await service.get('1').toPromise();
+        jest
+            .spyOn(service, "provider")
+            .mockReturnValue(mockProvider1);
+        await service.get("1").toPromise();
         // Second call should use cache (even if network fails)
         const mockProvider2 = {
-            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())))
+            request: jest
+                .fn()
+                .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default()))),
         };
-        jest.spyOn(service, 'provider').mockReturnValue(mockProvider2);
-        const result = await service.get('1').toPromise();
+        jest
+            .spyOn(service, "provider")
+            .mockReturnValue(mockProvider2);
+        const result = await service.get("1").toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('should handle network error when no cache', async () => {
+    it("should handle network error when no cache", async () => {
         const mockProvider = {
-            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())))
+            request: jest
+                .fn()
+                .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default()))),
         };
-        jest.spyOn(service, 'provider').mockReturnValue(mockProvider);
-        const result = await service.get('1').toPromise();
+        jest
+            .spyOn(service, "provider")
+            .mockReturnValue(mockProvider);
+        const result = await service.get("1").toPromise();
         expect(result?.hasFailed).toBe(true);
         expect(result?.alertModel).toBeInstanceOf(AlertModel);
     });
-    it('should get store list from network when no cache', async () => {
-        const response = { data: [{ id: '1', name: 'Store' }] };
+    it("should get store list from network when no cache", async () => {
+        const response = { data: [{ id: "1", name: "Store" }] };
         const mockProvider = {
-            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+            request: jest
+                .fn()
+                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
         };
-        jest.spyOn(service, 'provider').mockReturnValue(mockProvider);
+        jest
+            .spyOn(service, "provider")
+            .mockReturnValue(mockProvider);
         const result = await service.list().toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('should get store list from cache when available', async () => {
-        const response = { data: [{ id: '1', name: 'Store' }] };
+    it("should get store list from cache when available", async () => {
+        const response = { data: [{ id: "1", name: "Store" }] };
         // First call to populate cache
         const mockProvider1 = {
-            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+            request: jest
+                .fn()
+                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
         };
-        jest.spyOn(service, 'provider').mockReturnValue(mockProvider1);
+        jest
+            .spyOn(service, "provider")
+            .mockReturnValue(mockProvider1);
         await service.list().toPromise();
         // Second call should use cache
         const mockProvider2 = {
-            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())))
+            request: jest
+                .fn()
+                .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default()))),
         };
-        jest.spyOn(service, 'provider').mockReturnValue(mockProvider2);
+        jest
+            .spyOn(service, "provider")
+            .mockReturnValue(mockProvider2);
         const result = await service.list().toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('should get product category list from network when no cache', async () => {
-        const response = { data: [{ id: 'cat1', name: 'Category' }] };
+    it("should get product category list from network when no cache", async () => {
+        const response = { data: [{ id: "cat1", name: "Category" }] };
         const mockProvider = {
-            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+            request: jest
+                .fn()
+                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
         };
-        jest.spyOn(service, 'provider').mockReturnValue(mockProvider);
+        jest
+            .spyOn(service, "provider")
+            .mockReturnValue(mockProvider);
         const result = await service.productCategoryList().toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('should get product category list from cache when available', async () => {
-        const response = { data: [{ id: 'cat1', name: 'Category' }] };
+    it("should get product category list from cache when available", async () => {
+        const response = { data: [{ id: "cat1", name: "Category" }] };
         // First call to populate cache
         const mockProvider1 = {
-            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+            request: jest
+                .fn()
+                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
         };
-        jest.spyOn(service, 'provider').mockReturnValue(mockProvider1);
+        jest
+            .spyOn(service, "provider")
+            .mockReturnValue(mockProvider1);
         await service.productCategoryList().toPromise();
         // Second call should use cache
         const mockProvider2 = {
-            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())))
+            request: jest
+                .fn()
+                .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default()))),
         };
-        jest.spyOn(service, 'provider').mockReturnValue(mockProvider2);
+        jest
+            .spyOn(service, "provider")
+            .mockReturnValue(mockProvider2);
         const result = await service.productCategoryList().toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('should get product collection from network when no cache', async () => {
-        const response = { data: [{ id: 'prod1', name: 'Product' }] };
+    it("should get product collection from network when no cache", async () => {
+        const response = { data: [{ id: "prod1", name: "Product" }] };
         const payload = { page: 1, per_page: 10 };
         const mockProvider = {
-            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+            request: jest
+                .fn()
+                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
         };
-        jest.spyOn(service, 'provider').mockReturnValue(mockProvider);
-        const result = await service.productCollection('1', payload).toPromise();
+        jest
+            .spyOn(service, "provider")
+            .mockReturnValue(mockProvider);
+        const result = await service.productCollection("1", payload).toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('should get product collection from cache when available', async () => {
-        const response = { data: [{ id: 'prod1', name: 'Product' }] };
+    it("should get product collection from cache when available", async () => {
+        const response = { data: [{ id: "prod1", name: "Product" }] };
         const payload = { page: 1, per_page: 10 };
         // First call to populate cache
         const mockProvider1 = {
-            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+            request: jest
+                .fn()
+                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
         };
-        jest.spyOn(service, 'provider').mockReturnValue(mockProvider1);
-        await service.productCollection('1', payload).toPromise();
+        jest
+            .spyOn(service, "provider")
+            .mockReturnValue(mockProvider1);
+        await service.productCollection("1", payload).toPromise();
         // Second call should use cache
         const mockProvider2 = {
-            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())))
+            request: jest
+                .fn()
+                .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default()))),
         };
-        jest.spyOn(service, 'provider').mockReturnValue(mockProvider2);
-        const result = await service.productCollection('1', payload).toPromise();
+        jest
+            .spyOn(service, "provider")
+            .mockReturnValue(mockProvider2);
+        const result = await service.productCollection("1", payload).toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('should get featured product list from network when no cache', async () => {
-        const response = { data: [{ id: 'feat1', name: 'Featured' }] };
+    it("should get featured product list from network when no cache", async () => {
+        const response = {
+            data: [{ id: "feat1", name: "Featured" }],
+        };
         const mockProvider = {
-            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+            request: jest
+                .fn()
+                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
         };
-        jest.spyOn(service, 'provider').mockReturnValue(mockProvider);
-        const result = await service.featuredProductList('1').toPromise();
+        jest
+            .spyOn(service, "provider")
+            .mockReturnValue(mockProvider);
+        const result = await service.featuredProductList("1").toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('should get featured product list from cache when available', async () => {
-        const response = { data: [{ id: 'feat1', name: 'Featured' }] };
+    it("should get featured product list from cache when available", async () => {
+        const response = {
+            data: [{ id: "feat1", name: "Featured" }],
+        };
         // First call to populate cache
         const mockProvider1 = {
-            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+            request: jest
+                .fn()
+                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
         };
-        jest.spyOn(service, 'provider').mockReturnValue(mockProvider1);
-        await service.featuredProductList('1').toPromise();
+        jest
+            .spyOn(service, "provider")
+            .mockReturnValue(mockProvider1);
+        await service.featuredProductList("1").toPromise();
         // Second call should use cache
         const mockProvider2 = {
-            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default())))
+            request: jest
+                .fn()
+                .mockReturnValue(of(NetworkingUIEventWrapped.failed(AlertModel.default()))),
         };
-        jest.spyOn(service, 'provider').mockReturnValue(mockProvider2);
-        const result = await service.featuredProductList('1').toPromise();
+        jest
+            .spyOn(service, "provider")
+            .mockReturnValue(mockProvider2);
+        const result = await service.featuredProductList("1").toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(result?.response).toEqual(response);
     });
-    it('should clear cache successfully', async () => {
-        const response = { data: { id: '1', name: 'Store' } };
+    it("should clear cache successfully", async () => {
+        const response = { data: { id: "1", name: "Store" } };
         const mockProvider = {
-            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+            request: jest
+                .fn()
+                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
         };
-        jest.spyOn(service, 'provider').mockReturnValue(mockProvider);
+        jest
+            .spyOn(service, "provider")
+            .mockReturnValue(mockProvider);
         // Populate cache
-        await service.get('1').toPromise();
+        await service.get("1").toPromise();
         // Clear cache
         await service.clearCache();
         // Should call network again after cache clear
-        const result = await service.get('1').toPromise();
+        const result = await service.get("1").toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(mockProvider.request).toHaveBeenCalledTimes(2); // Once before clear, once after
     });
-    it('should clear specific store cache', async () => {
-        const response = { data: { id: '1', name: 'Store' } };
+    it("should clear specific store cache", async () => {
+        const response = { data: { id: "1", name: "Store" } };
         const mockProvider = {
-            request: jest.fn().mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response)))
+            request: jest
+                .fn()
+                .mockReturnValue(of(NetworkingUIEventWrapped.succeeded(response))),
         };
-        jest.spyOn(service, 'provider').mockReturnValue(mockProvider);
+        jest
+            .spyOn(service, "provider")
+            .mockReturnValue(mockProvider);
         // Populate cache for store '1'
-        await service.get('1').toPromise();
+        await service.get("1").toPromise();
         // Clear specific store cache
-        await service.clearStoreCache('1');
+        await service.clearStoreCache("1");
         // Should call network again after cache clear
-        const result = await service.get('1').toPromise();
+        const result = await service.get("1").toPromise();
         expect(result?.hasSuccess).toBe(true);
         expect(mockProvider.request).toHaveBeenCalledTimes(2);
     });

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

@@ -1,6 +1,6 @@
-import { BaseProvider } from '../core/base.provider';
-import { BaseServiceWrapper } from '../core/base.service.wrapper';
-import { NetworkingConfig } from '../types/types';
+import { BaseProvider } from "../core/base.provider";
+import { BaseServiceWrapper } from "../core/base.service.wrapper";
+import { NetworkingConfig } from "../types/types";
 export interface User {
     id: number;
     name: string;

package/dist/services/user.service.js

@@ -1,14 +1,14 @@
-import { BaseProvider } from '../core/base.provider';
-import { BaseServiceWrapper } from '../core/base.service.wrapper';
+import { BaseProvider } from "../core/base.provider";
+import { BaseServiceWrapper } from "../core/base.service.wrapper";
 // UserProvider implements ProviderType for user endpoints
 export class UserProvider extends BaseProvider {
     constructor(config, userId) {
         super({
             config,
-            path: userId ? `/users/${userId}` : '/users',
-            method: 'GET',
+            path: userId ? `/users/${userId}` : "/users",
+            method: "GET",
             headers: {},
-            getPath: () => (userId ? `/users/${userId}` : '/users'),
+            getPath: () => (userId ? `/users/${userId}` : "/users"),
         });
     }
 }
@@ -19,16 +19,19 @@ export class UserService extends BaseServiceWrapper {
     }
     // Fetch a user by ID
     fetchUserById(id) {
-        this.provider = new UserProvider({ baseUrl: 'https://jsonplaceholder.typicode.com', isProd: false }, id);
+        this.provider = new UserProvider({ baseUrl: "https://jsonplaceholder.typicode.com", isProd: false }, id);
         return this.request();
     }
     // Fetch all users
     fetchAllUsers() {
-        this.provider = new UserProvider({ baseUrl: 'https://jsonplaceholder.typicode.com', isProd: false });
+        this.provider = new UserProvider({
+            baseUrl: "https://jsonplaceholder.typicode.com",
+            isProd: false,
+        });
         return this.request();
     }
 }
 // Example usage:
 // setNetworkingConfig({ baseUrl: 'https://jsonplaceholder.typicode.com', isProd: false });
 // const userService = new UserService();
-// userService.fetchUserById(1).subscribe(result => console.log(result)); 
+// userService.fetchUserById(1).subscribe(result => console.log(result));

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

@@ -1,44 +1,50 @@
-import { UserService } from './user.service';
-import { NetworkingUIEventWrapped } from '../types/types';
-import { of, throwError } from 'rxjs';
-import { BaseServiceWrapper } from '../core/base.service.wrapper';
-describe('UserService', () => {
+import { UserService } from "./user.service";
+import { NetworkingUIEventWrapped } from "../types/types";
+import { of, throwError } from "rxjs";
+import { BaseServiceWrapper } from "../core/base.service.wrapper";
+describe("UserService", () => {
     const config = {
-        baseUrl: 'https://jsonplaceholder.typicode.com',
+        baseUrl: "https://jsonplaceholder.typicode.com",
         isProd: false,
-        clientId: 'test-client',
-        apiKey: 'test-key',
+        clientId: "test-client",
+        apiKey: "test-key",
     };
-    const user = { id: 1, name: 'Test', email: 'test@example.com' };
+    const user = { id: 1, name: "Test", email: "test@example.com" };
     let requestSpy;
     beforeEach(() => {
-        requestSpy = jest.spyOn(BaseServiceWrapper.prototype, 'request').mockImplementation(() => of(NetworkingUIEventWrapped.succeeded(user)));
+        requestSpy = jest
+            .spyOn(BaseServiceWrapper.prototype, "request")
+            .mockImplementation(() => of(NetworkingUIEventWrapped.succeeded(user)));
     });
     afterEach(() => {
         requestSpy.mockRestore();
     });
-    it('fetchUserById should return user (success)', (done) => {
+    it("fetchUserById should return user (success)", (done) => {
         const service = new UserService(config);
-        service.fetchUserById(1).subscribe((result) => {
+        service
+            .fetchUserById(1)
+            .subscribe((result) => {
             expect(result.response).toEqual(user);
             done();
         });
     });
-    it('fetchAllUsers should return users (success)', (done) => {
+    it("fetchAllUsers should return users (success)", (done) => {
         const service = new UserService(config);
-        service.fetchAllUsers().subscribe((result) => {
+        service
+            .fetchAllUsers()
+            .subscribe((result) => {
             expect(result.response).toEqual(user);
             done();
         });
     });
-    it('request should handle error', (done) => {
-        requestSpy.mockImplementationOnce(() => throwError(() => new Error('Test error')));
+    it("request should handle error", (done) => {
+        requestSpy.mockImplementationOnce(() => throwError(() => new Error("Test error")));
         const service = new UserService(config);
         // Simulate error by calling a method that uses request
         service.fetchUserById(1).subscribe({
             error: (err) => {
                 expect(err).toBeInstanceOf(Error);
-                expect(err.message).toBe('Test error');
+                expect(err.message).toBe("Test error");
                 done();
             },
         });

package/dist/types/types.js

@@ -4,10 +4,10 @@ export class AlertButtonModel {
         this.handler = handler;
     }
     static buttonYes(handler) {
-        return new AlertButtonModel('Yes', handler);
+        return new AlertButtonModel("Yes", handler);
     }
     static buttonNo(handler) {
-        return new AlertButtonModel('No', handler);
+        return new AlertButtonModel("No", handler);
     }
 }
 export class AlertModel {
@@ -26,7 +26,7 @@ export class AlertModel {
         return this.httpErrorCode == 0;
     }
     static default() {
-        return new AlertModel('Generic Error', 0, true, '', null, [
+        return new AlertModel("Generic Error", 0, true, "", null, [
             AlertButtonModel.buttonYes(),
         ]);
     }

package/dist/types/types.test.js

@@ -1,14 +1,14 @@
-import { NetworkingUIEventWrapped, AlertModel } from './types';
-describe('NetworkingUIEventWrapped', () => {
-    it('should wrap succeeded response', () => {
-        const wrap = NetworkingUIEventWrapped.succeeded({ foo: 'bar' });
-        expect(wrap.response).toEqual({ foo: 'bar' });
+import { NetworkingUIEventWrapped, AlertModel } from "./types";
+describe("NetworkingUIEventWrapped", () => {
+    it("should wrap succeeded response", () => {
+        const wrap = 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 AlertModel('err', 500, true, 'Error', { detail: 'fail' });
+    it("should wrap failed response and set alertModel", () => {
+        const alert = new AlertModel("err", 500, true, "Error", { detail: "fail" });
         const wrap = NetworkingUIEventWrapped.failed(alert);
         expect(wrap.response).toBeNull();
         expect(wrap.hasSuccess).toBe(false);
@@ -16,7 +16,7 @@ describe('NetworkingUIEventWrapped', () => {
         expect(wrap.isWaiting).toBe(false);
         expect(wrap.alertModel).toBe(alert);
     });
-    it('should wrap waiting state', () => {
+    it("should wrap waiting state", () => {
         const wrap = NetworkingUIEventWrapped.waiting();
         expect(wrap.isWaiting).toBe(true);
         expect(wrap.hasSuccess).toBe(false);

package/dist/utils/cache-import.d.ts

@@ -1,3 +1,3 @@
-import Dexie from 'dexie';
+import Dexie from "dexie";
 export { Dexie };
 export type Table<T> = Dexie.Table<T, string>;

package/dist/utils/cache-import.js

@@ -1,2 +1,2 @@
-import Dexie from 'dexie';
+import Dexie from "dexie";
 export { Dexie };

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

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

package/dist/utils/networking-import.js

@@ -1,3 +1,3 @@
-export * from 'axios';
-import axios, { HttpStatusCode } from 'axios';
+export * from "axios";
+import axios, { HttpStatusCode } from "axios";
 export { axios, HttpStatusCode };

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

@@ -1,5 +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';
+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 { 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/utils/rxjs-import.js

@@ -1,5 +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';
+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 { 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smess/networking",
-  "version": "1.0.9",
+  "version": "1.0.12",
   "description": "Networking utilities and services for SMESS platform.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",