@yuno-payments/sdk-event-log 0.3.0-beta.8 → 1.0.0-beta.0

package/dist/esm/database/local-storage/local-storage.test.js

@@ -12,19 +12,20 @@ const batch = {
 describe('LocalStorageDatabase', () => {
     let localStorageDatabase;
     beforeEach(() => {
-        localStorageDatabase = new local_storage_1.LocalStorage();
+        localStorageDatabase = new local_storage_1.LocalStorage('test');
     });
     afterEach(() => {
         localStorage.clear();
     });
     it('should set an item in the database', async () => {
-        await localStorageDatabase.setItem(batch);
-        const database = JSON.parse(localStorage.getItem('YUNO_EVENT_LOGS') || '[]');
-        expect(database).toContainEqual(batch);
+        const testKey = 'testKey';
+        await localStorageDatabase.setItem(batch, testKey);
+        const database = JSON.parse(localStorage.getItem('YUNO_EVENT_LOGS_test') || '[]');
+        expect(database).toEqual({ [testKey]: [batch] });
     });
     it('should get an item from the database', async () => {
-        localStorage.setItem('YUNO_EVENT_LOGS', JSON.stringify([batch]));
+        localStorage.setItem('YUNO_EVENT_LOGS_test', JSON.stringify({ testKey: [batch] }));
         const result = await localStorageDatabase.getAllItems();
-        expect(result).toEqual([batch]);
+        expect(result).toEqual({ testKey: [batch] });
     });
 });

package/dist/esm/database/memory-storage/memory-storage.d.ts

@@ -4,8 +4,10 @@ export declare class MemoryStorage implements Database {
     #private;
     constructor();
     reset(): Promise<void>;
-    setItem(item: Batch): Promise<void>;
+    setItem(item: Batch, publicApiKey: string): Promise<void>;
     getItem(id: string): Promise<Batch>;
     removeItem(id: string): Promise<void>;
-    getAllItems(): Promise<Batch[]>;
+    getAllItems(): Promise<{
+        [x: string]: Batch[];
+    }>;
 }

package/dist/esm/database/memory-storage/memory-storage.js

@@ -16,13 +16,16 @@ exports.MemoryStorage = void 0;
 class MemoryStorage {
     constructor() {
         _MemoryStorage_items.set(this, void 0);
-        __classPrivateFieldSet(this, _MemoryStorage_items, [], "f");
+        __classPrivateFieldSet(this, _MemoryStorage_items, {}, "f");
     }
     async reset() {
-        __classPrivateFieldSet(this, _MemoryStorage_items, [], "f");
+        __classPrivateFieldSet(this, _MemoryStorage_items, {}, "f");
     }
-    async setItem(item) {
-        __classPrivateFieldGet(this, _MemoryStorage_items, "f").push(item);
+    async setItem(item, publicApiKey) {
+        if (__classPrivateFieldGet(this, _MemoryStorage_items, "f")[publicApiKey] === undefined) {
+            __classPrivateFieldGet(this, _MemoryStorage_items, "f")[publicApiKey] = [];
+        }
+        __classPrivateFieldGet(this, _MemoryStorage_items, "f")[publicApiKey].push(item);
     }
     getItem(id) {
         throw new Error('Method not implemented.' + id);
@@ -31,7 +34,9 @@ class MemoryStorage {
         throw new Error('Method not implemented.' + id);
     }
     getAllItems() {
-        return Promise.resolve(__classPrivateFieldGet(this, _MemoryStorage_items, "f"));
+        const items = { ...__classPrivateFieldGet(this, _MemoryStorage_items, "f") };
+        this.reset();
+        return Promise.resolve(items);
     }
 }
 exports.MemoryStorage = MemoryStorage;

package/dist/esm/database/memory-storage/memory-storage.test.js

@@ -18,8 +18,8 @@ describe('MemoryStorage', () => {
         memoryStorage.reset();
     });
     it('should set an item in the database', async () => {
-        await memoryStorage.setItem(batch);
+        await memoryStorage.setItem(batch, 'testKey');
         const database = await memoryStorage.getAllItems();
-        expect(database).toEqual([batch]);
+        expect(database).toEqual({ testKey: [batch] });
     });
 });

package/dist/esm/index.d.ts

@@ -1,15 +1,13 @@
 import { InitArgs } from './index.types';
-import './database';
 import { Event, Log } from './types';
-declare class EventLog {
+export declare class EventLog {
     #private;
-    init({ publicApiKey, platform, batchTime, enableEvents, enableLogs, debug }: InitArgs): void;
-    event(eventArgs: Omit<Event, 'type'>): Promise<void> | undefined;
+    constructor({ organizationName, platform, batchTime, enableEvents, enableLogs, debug, }: InitArgs);
+    event(eventArgs: Omit<Event, 'type'>, publicApiKey: string): Promise<void> | undefined;
     logger: {
-        error: (errorArgs: Omit<Log, 'level' | 'type'>) => Promise<void> | undefined;
-        debug: (debugArgs: Omit<Log, 'level' | 'type'>) => Promise<void> | undefined;
-        info: (infoArgs: Omit<Log, 'level' | 'type'>) => Promise<void> | undefined;
+        error: (errorArgs: Omit<Log, 'level' | 'type'>, publicApiKey: string) => Promise<void> | undefined;
+        debug: (debugArgs: Omit<Log, 'level' | 'type'>, publicApiKey: string) => Promise<void> | undefined;
+        info: (infoArgs: Omit<Log, 'level' | 'type'>, publicApiKey: string) => Promise<void> | undefined;
     };
+    sendBatch(): Promise<void>;
 }
-export declare const eventLog: EventLog;
-export {};

package/dist/esm/index.js

@@ -10,43 +10,58 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _EventLog_enableEvents, _EventLog_enableLogs;
+var _EventLog_enableEvents, _EventLog_enableLogs, _EventLog_api, _EventLog_database;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.eventLog = void 0;
+exports.EventLog = void 0;
 const api_1 = require("./api");
-require("./database");
 const cron_1 = require("./cron");
 const types_1 = require("./types");
 const database_1 = require("./database");
 const index_utils_1 = require("./index.utils");
 class EventLog {
-    constructor() {
-        _EventLog_enableEvents.set(this, false);
-        _EventLog_enableLogs.set(this, false);
+    constructor({ organizationName, platform = 'web', batchTime, enableEvents = true, enableLogs = true, debug = false, }) {
+        _EventLog_enableEvents.set(this, void 0);
+        _EventLog_enableLogs.set(this, void 0);
+        _EventLog_api.set(this, void 0);
+        _EventLog_database.set(this, void 0);
         this.logger = {
-            error: (errorArgs) => {
-                return (0, index_utils_1.setLog)(errorArgs, types_1.Level.ERROR, __classPrivateFieldGet(this, _EventLog_enableLogs, "f"));
+            error: (errorArgs, publicApiKey) => {
+                return (0, index_utils_1.setLog)(errorArgs, types_1.Level.ERROR, __classPrivateFieldGet(this, _EventLog_enableLogs, "f"), __classPrivateFieldGet(this, _EventLog_database, "f"), publicApiKey, index_utils_1.browserClientInfo);
             },
-            debug: (debugArgs) => {
-                return (0, index_utils_1.setLog)(debugArgs, types_1.Level.DEBUG, __classPrivateFieldGet(this, _EventLog_enableLogs, "f"));
+            debug: (debugArgs, publicApiKey) => {
+                return (0, index_utils_1.setLog)(debugArgs, types_1.Level.DEBUG, __classPrivateFieldGet(this, _EventLog_enableLogs, "f"), __classPrivateFieldGet(this, _EventLog_database, "f"), publicApiKey, index_utils_1.browserClientInfo);
+            },
+            info: (infoArgs, publicApiKey) => {
+                return (0, index_utils_1.setLog)(infoArgs, types_1.Level.INFO, __classPrivateFieldGet(this, _EventLog_enableLogs, "f"), __classPrivateFieldGet(this, _EventLog_database, "f"), publicApiKey, index_utils_1.browserClientInfo);
             },
-            info: (infoArgs) => {
-                return (0, index_utils_1.setLog)(infoArgs, types_1.Level.INFO, __classPrivateFieldGet(this, _EventLog_enableLogs, "f"));
-            }
         };
-    }
-    init({ publicApiKey, platform = 'web', batchTime, enableEvents, enableLogs, debug = false }) {
         __classPrivateFieldSet(this, _EventLog_enableEvents, enableEvents, "f");
         __classPrivateFieldSet(this, _EventLog_enableLogs, enableLogs, "f");
-        api_1.api.init(publicApiKey, platform, debug);
-        cron_1.cron.init(batchTime);
+        __classPrivateFieldSet(this, _EventLog_api, new api_1.Api(platform, debug), "f");
+        __classPrivateFieldSet(this, _EventLog_database, (0, database_1.databaseFactory)(organizationName), "f");
+        if (batchTime) {
+            new cron_1.Cron(batchTime, __classPrivateFieldGet(this, _EventLog_api, "f"), __classPrivateFieldGet(this, _EventLog_database, "f"));
+        }
     }
-    event(eventArgs) {
+    event(eventArgs, publicApiKey) {
         if (!__classPrivateFieldGet(this, _EventLog_enableEvents, "f")) {
             return;
         }
-        return database_1.database.setItem({ ...eventArgs, type: types_1.EventLogType.EVENT });
+        return __classPrivateFieldGet(this, _EventLog_database, "f").setItem({
+            os: index_utils_1.browserClientInfo === null || index_utils_1.browserClientInfo === void 0 ? void 0 : index_utils_1.browserClientInfo.os,
+            ...eventArgs,
+            type: types_1.EventLogType.EVENT,
+        }, publicApiKey);
+    }
+    async sendBatch() {
+        const items = await __classPrivateFieldGet(this, _EventLog_database, "f").getAllItems();
+        const keys = Object.keys(items);
+        if (keys.length) {
+            for (const key of keys) {
+                __classPrivateFieldGet(this, _EventLog_api, "f").sendBatch(items[key], key);
+            }
+        }
     }
 }
-_EventLog_enableEvents = new WeakMap(), _EventLog_enableLogs = new WeakMap();
-exports.eventLog = new EventLog();
+exports.EventLog = EventLog;
+_EventLog_enableEvents = new WeakMap(), _EventLog_enableLogs = new WeakMap(), _EventLog_api = new WeakMap(), _EventLog_database = new WeakMap();

package/dist/esm/index.test.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-magic-numbers */
 const index_1 = require("./index");
-const database_1 = require("./database");
-const cron_1 = require("./cron");
-const PUBLIC_API_KEY = 'staging_gAAAAABj-NC2WEf3XA4lHnN6RfGbjETf6qL27jlU7c1tm01ERV-Y-E6ddee1QPyV_CA8cxjVlGy-qDNA2-mqa9msQlTJit-Fmbvv6f2AZdfbFd_CUo1stvixnF4_8MzM_IYVWYz7KK86VfEBvxNpjRCyp7BDef-QzrT1-yqa8HAYTuA1GU3Hjjo=';
+const types_1 = require("./types");
+const node_1 = require("msw/node");
+const msw_1 = require("msw");
 const eventArgs = {
     source: 'test',
     event: 'testEvent',
@@ -15,92 +16,213 @@ const logArgs = {
     url: '',
     method: '',
     country: '',
-    original_created_at: new Date().toISOString()
+    original_created_at: new Date().toISOString(),
+};
+const browserClientInfo = {
+    browser: 'jsdom',
+    browserMajorVersion: 20,
+    browserVersion: '20.0.3',
+    cookies: true,
+    mobile: false,
+    os: '-',
+    osVersion: '-',
+    screen: '',
 };
+const metadata = {
+    browser_info: browserClientInfo,
+};
+const publicApiKey = 'prod_1';
+let mockInterceptRequest = jest.fn();
+const server = (0, node_1.setupServer)(
+// Describe the requests to mock.
+msw_1.rest.post('https://api.y.uno/v1/sdk/event-log/publish', (req, res, ctx) => {
+    mockInterceptRequest(req.body);
+    return res(ctx.status(200));
+}));
 describe('EventLog', () => {
+    let eventLog;
+    beforeAll(() => {
+        mockInterceptRequest = jest.fn();
+        server.listen();
+    });
+    // Reset any request handlers that we may add during the tests,
+    // so they don't affect other tests.
+    afterEach(() => server.resetHandlers());
+    // Clean up after the tests are finished.
+    afterAll(() => server.close());
     beforeEach(() => {
-        // Reset the database before each test
-        // to ensure a clean slate
-        index_1.eventLog.init({
-            publicApiKey: PUBLIC_API_KEY,
-            batchTime: 500,
-            enableEvents: true,
-            enableLogs: true,
+        eventLog = new index_1.EventLog({
+            organizationName: 'testOrg',
+            debug: false,
         });
-        database_1.database.reset();
     });
-    afterEach(async () => {
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        cron_1.cron.stop();
+    afterEach(() => {
+        jest.clearAllMocks();
     });
-    it('should add an event to the database', async () => {
-        index_1.eventLog.event(eventArgs);
-        const events = await database_1.database.getAllItems();
-        expect(events).toHaveLength(1);
-        expect(events[0]).toMatchObject(eventArgs);
-    });
-    it('should not add an event to the database if events are disabled', async () => {
-        index_1.eventLog.init({
-            publicApiKey: PUBLIC_API_KEY,
-            batchTime: 1000,
-            enableEvents: false,
-            enableLogs: true,
+    describe('event', () => {
+        it('should add an event to the database if events are enabled', async () => {
+            eventLog.event(eventArgs, publicApiKey);
+            eventLog.sendBatch();
+            await new Promise(process.nextTick);
+            expect(mockInterceptRequest).toHaveBeenCalledWith({
+                batch: [
+                    { ...eventArgs, os: browserClientInfo.os, type: types_1.EventLogType.EVENT },
+                ],
+            });
         });
-        index_1.eventLog.event(eventArgs);
-        const events = await database_1.database.getAllItems();
-        expect(events).toHaveLength(0);
-    });
-    it('should log an error', async () => {
-        index_1.eventLog.logger.error(logArgs);
-        index_1.eventLog.logger.error(logArgs);
-        const events = await database_1.database.getAllItems();
-        expect(events).toHaveLength(2);
-        expect(events[0]).toMatchObject(logArgs);
-        expect(events[1]).toMatchObject(logArgs);
-    });
-    it('should not log an error if logs are disabled', async () => {
-        index_1.eventLog.init({
-            publicApiKey: PUBLIC_API_KEY,
-            batchTime: 1000,
-            enableEvents: false,
-            enableLogs: false,
+        it('should not add an event to the database if events are disabled', async () => {
+            const publicApiKey = 'testApiKey';
+            eventLog = new index_1.EventLog({
+                organizationName: 'testOrg',
+                enableEvents: false,
+            });
+            eventLog.event(eventArgs, publicApiKey);
+            eventLog.sendBatch();
+            await new Promise(process.nextTick);
+            expect(mockInterceptRequest).not.toHaveBeenCalled();
         });
-        index_1.eventLog.logger.error(logArgs);
-        const events = await database_1.database.getAllItems();
-        expect(events).toHaveLength(0);
     });
-    it('should log a debug message', async () => {
-        index_1.eventLog.logger.debug(logArgs);
-        const events = await database_1.database.getAllItems();
-        expect(events).toHaveLength(1);
-        expect(events[0]).toMatchObject(logArgs);
-    });
-    it('should not log a debug message if logs are disabled', async () => {
-        index_1.eventLog.init({
-            publicApiKey: PUBLIC_API_KEY,
-            batchTime: 1000,
-            enableEvents: false,
-            enableLogs: false,
+    describe('logger', () => {
+        it('should add an error log to the database if logs are enabled', async () => {
+            eventLog.logger.error(logArgs, publicApiKey);
+            eventLog.sendBatch();
+            await new Promise(process.nextTick);
+            expect(mockInterceptRequest).toHaveBeenCalledWith({
+                batch: [
+                    {
+                        ...logArgs,
+                        os: browserClientInfo.os,
+                        metadata,
+                        type: types_1.EventLogType.LOG,
+                        level: types_1.Level.ERROR,
+                    },
+                ],
+            });
+        });
+        it('should not add an error log to the database if logs are disabled', async () => {
+            const publicApiKey = 'testApiKey';
+            eventLog = new index_1.EventLog({
+                organizationName: 'testOrg',
+                enableEvents: true,
+                enableLogs: false,
+                debug: false,
+            });
+            eventLog.logger.error(logArgs, publicApiKey);
+            eventLog.sendBatch();
+            await new Promise(process.nextTick);
+            expect(mockInterceptRequest).not.toHaveBeenCalled();
+        });
+        it('should add a debug log to the database if logs are enabled', async () => {
+            eventLog.logger.debug(logArgs, publicApiKey);
+            eventLog.sendBatch();
+            await new Promise(process.nextTick);
+            expect(mockInterceptRequest).toHaveBeenCalledWith({
+                batch: [
+                    {
+                        ...logArgs,
+                        os: browserClientInfo.os,
+                        metadata,
+                        type: types_1.EventLogType.LOG,
+                        level: types_1.Level.DEBUG,
+                    },
+                ],
+            });
+        });
+        it('should not add a debug log to the database if logs are disabled', async () => {
+            const publicApiKey = 'testApiKey';
+            eventLog = new index_1.EventLog({
+                organizationName: 'testOrg',
+                platform: 'web',
+                enableEvents: true,
+                enableLogs: false,
+                debug: false,
+            });
+            eventLog.logger.debug(logArgs, publicApiKey);
+            eventLog.sendBatch();
+            await new Promise(process.nextTick);
+            expect(mockInterceptRequest).not.toHaveBeenCalled();
+        });
+        it('should add an info log to the database if logs are enabled', async () => {
+            eventLog.logger.info(logArgs, publicApiKey);
+            eventLog.sendBatch();
+            await new Promise(process.nextTick);
+            expect(mockInterceptRequest).toHaveBeenCalledWith({
+                batch: [
+                    {
+                        ...logArgs,
+                        os: browserClientInfo.os,
+                        metadata,
+                        type: types_1.EventLogType.LOG,
+                        level: types_1.Level.INFO,
+                    },
+                ],
+            });
+        });
+        it('should not add an info log to the database if logs are disabled', async () => {
+            eventLog = new index_1.EventLog({
+                organizationName: 'testOrg',
+                platform: 'web',
+                enableEvents: true,
+                enableLogs: false,
+                debug: false,
+            });
+            eventLog.sendBatch();
+            await new Promise(process.nextTick);
+            expect(mockInterceptRequest).not.toHaveBeenCalled();
         });
-        index_1.eventLog.logger.debug(logArgs);
-        const events = await database_1.database.getAllItems();
-        expect(events).toHaveLength(0);
     });
-    it('should log an info message', async () => {
-        index_1.eventLog.logger.info(logArgs);
-        const events = await database_1.database.getAllItems();
-        expect(events).toHaveLength(1);
-        expect(events[0]).toMatchObject(logArgs);
+    describe('sendBatch', () => {
+        it('should not send a batch of items to the API if there are no items in the database', async () => {
+            await eventLog.sendBatch();
+            await new Promise(process.nextTick);
+            expect(mockInterceptRequest).not.toHaveBeenCalled();
+        });
     });
-    it('should not log an info message if logs are disabled', async () => {
-        index_1.eventLog.init({
-            publicApiKey: PUBLIC_API_KEY,
-            batchTime: 1000,
-            enableEvents: false,
-            enableLogs: false,
+    describe('Cron', () => {
+        it('should send a batch of items to the API', async () => {
+            eventLog = new index_1.EventLog({
+                organizationName: 'testOrg',
+                platform: 'web',
+                batchTime: 1000,
+                enableEvents: true,
+                enableLogs: true,
+                debug: false,
+            });
+            await eventLog.event(eventArgs, publicApiKey);
+            await eventLog.logger.error(logArgs, publicApiKey);
+            await eventLog.logger.debug(logArgs, publicApiKey);
+            await eventLog.logger.info(logArgs, publicApiKey);
+            await new Promise((resolve) => setTimeout(resolve, 1200));
+            expect(mockInterceptRequest).toHaveBeenCalledWith({
+                batch: [
+                    {
+                        ...eventArgs,
+                        os: browserClientInfo.os,
+                        type: types_1.EventLogType.EVENT,
+                    },
+                    {
+                        ...logArgs,
+                        os: browserClientInfo.os,
+                        metadata,
+                        type: types_1.EventLogType.LOG,
+                        level: types_1.Level.ERROR,
+                    },
+                    {
+                        ...logArgs,
+                        os: browserClientInfo.os,
+                        metadata,
+                        type: types_1.EventLogType.LOG,
+                        level: types_1.Level.DEBUG,
+                    },
+                    {
+                        ...logArgs,
+                        os: browserClientInfo.os,
+                        metadata,
+                        type: types_1.EventLogType.LOG,
+                        level: types_1.Level.INFO,
+                    },
+                ],
+            });
         });
-        index_1.eventLog.logger.info(logArgs);
-        const events = await database_1.database.getAllItems();
-        expect(events).toHaveLength(0);
     });
 });

package/dist/esm/index.types.d.ts

@@ -1,8 +1,8 @@
 export type InitArgs = {
-    publicApiKey: string;
-    batchTime: number;
-    enableEvents: boolean;
-    enableLogs: boolean;
+    organizationName: string;
+    batchTime?: number;
+    enableEvents?: boolean;
+    enableLogs?: boolean;
     platform?: string;
     debug?: boolean;
 };

package/dist/esm/index.utils.d.ts

@@ -1,2 +1,5 @@
-import { Level, Log } from './types';
-export declare function setLog(logArgs: Omit<Log, 'level' | 'type'>, level: Level, enableLog: boolean): Promise<void> | undefined;
+import { Database } from './database';
+import { BrowserClientInfo, Level, Log } from './types';
+export declare function setLog(logArgs: Omit<Log, 'level' | 'type'>, level: Level, enableLog: boolean, database: Database, publicApiKey: string, browserInfo: BrowserClientInfo | null): Promise<void> | undefined;
+declare let browserClientInfo: BrowserClientInfo | null;
+export { browserClientInfo };

package/dist/esm/index.utils.js

@@ -1,12 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setLog = void 0;
-const database_1 = require("./database");
+exports.browserClientInfo = exports.setLog = void 0;
 const types_1 = require("./types");
-function setLog(logArgs, level, enableLog) {
+const utils_1 = require("./utils");
+const utils_2 = require("./utils");
+function setLog(logArgs, level, enableLog, database, publicApiKey, browserInfo) {
     if (!enableLog) {
         return;
     }
-    return database_1.database.setItem({ ...logArgs, level, type: types_1.EventLogType.LOG });
+    return database.setItem({
+        os: browserInfo === null || browserInfo === void 0 ? void 0 : browserInfo.os,
+        ...logArgs,
+        metadata: {
+            ...logArgs.metadata,
+            browser_info: browserInfo,
+        },
+        level,
+        type: types_1.EventLogType.LOG,
+    }, publicApiKey);
 }
 exports.setLog = setLog;
+let browserClientInfo = null;
+exports.browserClientInfo = browserClientInfo;
+if ((0, utils_1.isBrowser)()) {
+    (0, utils_2.clientDetection)().then((clientInfo) => {
+        exports.browserClientInfo = browserClientInfo = clientInfo;
+    });
+}

package/dist/esm/types/index.d.ts

@@ -23,7 +23,7 @@ export type Log = BaseEventLog & {
     response?: object | null;
     status_code?: string | null;
     trace_id?: string | null;
-    metadata?: unknown | null;
+    metadata?: object | null;
     country?: string | null;
     organization_name?: string | null;
     level: Level;
@@ -38,4 +38,14 @@ export type Event = BaseEventLog & {
     headers?: object;
 };
 export type Batch = Log | Event;
+export type BrowserClientInfo = {
+    screen: string;
+    browser: string;
+    browserVersion: string;
+    browserMajorVersion: number;
+    mobile: boolean;
+    os: string;
+    osVersion: string | number | undefined;
+    cookies: boolean;
+};
 export {};

package/dist/esm/utils/__tests__/check-environment.test.d.ts

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

package/dist/esm/utils/__tests__/check-environment.test.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const check_environment_1 = require("../check-environment");
+describe('isLocalStorageEnabled', () => {
+    it('should return true if local storage is enabled', () => {
+        expect((0, check_environment_1.isLocalStorageEnabled)()).toBe(true);
+    });
+    it('should return false if local storage is disabled', () => {
+        const localStorageMock = {
+            getItem: jest.fn(() => null),
+            setItem: jest.fn(() => {
+                throw new Error('Local storage is disabled');
+            }),
+            removeItem: jest.fn(() => null),
+        };
+        Object.defineProperty(window, 'localStorage', {
+            value: localStorageMock,
+        });
+        expect((0, check_environment_1.isLocalStorageEnabled)()).toBe(false);
+    });
+});
+describe('isBrowser', () => {
+    it('should return true if running in a browser environment', () => {
+        expect((0, check_environment_1.isBrowser)()).toBe(true);
+    });
+    it('should return false if running in a non-browser environment', () => {
+        const isBrowserMock = new Function('try {return this===window;}catch(e){ return false;}').bind({});
+        expect(isBrowserMock()).toBe(false);
+    });
+});

package/dist/esm/utils/__tests__/client-detection.test.d.ts

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

package/dist/esm/utils/__tests__/client-detection.test.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-magic-numbers */
+const client_detection_1 = require("../client-detection");
+describe('clientDetection', () => {
+    it('should return an object with screen, browser, browserVersion, browserMajorVersion, mobile, os, osVersion, and cookies properties', async () => {
+        const result = await (0, client_detection_1.clientDetection)();
+        expect(result).toHaveProperty('screen');
+        expect(result).toHaveProperty('browser');
+        expect(result).toHaveProperty('browserVersion');
+        expect(result).toHaveProperty('browserMajorVersion');
+        expect(result).toHaveProperty('mobile');
+        expect(result).toHaveProperty('os');
+        expect(result).toHaveProperty('osVersion');
+        expect(result).toHaveProperty('cookies');
+    });
+    it('should correctly detect the browser and browser version', async () => {
+        const result = await (0, client_detection_1.clientDetection)();
+        expect(result.browser).toBe('jsdom');
+        expect(result.browserVersion).toBe('20.0.3');
+        expect(result.browserMajorVersion).toBeGreaterThanOrEqual(20);
+    });
+    it('should correctly detect whether the client is mobile', async () => {
+        const result = await (0, client_detection_1.clientDetection)();
+        expect(result.mobile).toBe(false);
+    });
+    it('should correctly detect whether cookies are enabled', async () => {
+        const result = await (0, client_detection_1.clientDetection)();
+        expect(result.cookies).toBe(true);
+    });
+});

package/dist/esm/utils/check-environment.d.ts

@@ -0,0 +1,2 @@
+export declare function isLocalStorageEnabled(): boolean;
+export declare const isBrowser: Function;