@wildix/xbees-connect 1.2.0-alpha.4 → 1.2.0-alpha.8

package/dist-es/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wildix/xbees-connect",
-    "version": "1.2.0-alpha.4",
+    "version": "1.2.0-alpha.8",
     "description": "This library provides easy communication between x-bees and integrated web applications",
     "author": "dimitri.chernykh <dimitri.chernykh@wildix.com>",
     "homepage": "",
@@ -17,7 +17,10 @@
         "build:docs": "typedoc",
         "lint": "eslint . && tsc --noEmit",
         "lint:fix": "eslint . --fix",
-        "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo"
+        "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo",
+        "test": "jest",
+        "test:watch": "jest --watch",
+        "test:coverage": "jest --coverage"
     },
     "files": [
         "dist-*/**"
@@ -30,8 +33,12 @@
         "access": "public"
     },
     "devDependencies": {
+        "@types/jest": "^29.5.12",
         "eslint": "^8.55.0",
+        "eslint-plugin-jest": "^28.5.0",
+        "jest": "^29.7.0",
         "rimraf": "^5.0.5",
+        "ts-jest": "^29.1.3",
         "typescript": "^5.3.3"
     },
     "parserOptions": {

package/dist-es/src/Client.js

@@ -129,16 +129,17 @@ export class Client {
         return this.sendAsync({ type: ClientEventType.AUTHORIZED });
     }
     addEventListener(eventName, callback) {
-        return this.messageListener.addEventListener(eventName, callback);
+        return MessageListener.getInstance().listen(eventName, callback);
     }
     removeEventListener(eventName, callback) {
-        this.messageListener.removeEventListener(eventName, callback);
+        MessageListener.getInstance().off(eventName, callback);
     }
     off(callback) {
         this.localStorageManager.removeOnStorage(callback);
         this.removeEventListener(null, callback);
     }
     onRedirectQuery(callback) {
+        console.debug('onRedirectQuery', 'listen');
         return this.addEventListener(EventType.REDIRECT_QUERY, callback);
     }
     onCallEnded(callback) {

package/dist-es/src/__tests__/Client.test.js

@@ -0,0 +1,259 @@
+import { Client } from '../Client';
+import { ClientEventType, EventType } from '../enums';
+import ClientParams from '../helpers/ClientParams';
+import LocalStorageManager from '../helpers/LocalStorageManager';
+import { MessageListener } from '../helpers/MessageListener';
+import PostMessageController from '../helpers/PostMessageController';
+import TechnicalSupport from '../helpers/TechnicalSupport';
+jest.mock('../../package.json', () => ({ version: '1.0.0' }));
+jest.mock('../helpers/ClientParams');
+jest.mock('../helpers/LocalStorageManager');
+jest.mock('../helpers/MessageListener');
+jest.mock('../helpers/PostMessageController');
+jest.mock('../helpers/TechnicalSupport');
+describe('Client', () => {
+    let clientInstance;
+    let originalWindow;
+    beforeAll(() => {
+        originalWindow = { ...globalThis.window };
+    });
+    beforeEach(() => {
+        Client.instance = null;
+        clientInstance = Client.getInstance();
+        jest.clearAllMocks();
+        globalThis.window = {
+            ...originalWindow,
+            addEventListener: jest.fn(),
+            removeEventListener: jest.fn(),
+            location: { host: 'http://example.com' },
+        };
+    });
+    afterAll(() => {
+        globalThis.window = originalWindow;
+    });
+    it('should return a singleton instance', () => {
+        const instance1 = Client.getInstance();
+        const instance2 = Client.getInstance();
+        expect(instance1).toBe(instance2);
+    });
+    it('should initialize correctly based on showsUi()', async () => {
+        const renderer = jest.fn().mockResolvedValue(undefined);
+        jest.spyOn(clientInstance, 'showsUi').mockReturnValue(true);
+        Client.initialize(renderer);
+        await Promise.resolve();
+        expect(renderer).toHaveBeenCalled();
+    });
+    it('should initialize and call ready when showsUi() is false', async () => {
+        const renderer = jest.fn().mockResolvedValue(undefined);
+        jest.spyOn(clientInstance, 'showsUi').mockReturnValue(false);
+        const readySpy = jest.spyOn(clientInstance, 'ready').mockResolvedValue({});
+        Client.initialize(renderer);
+        await Promise.resolve();
+        expect(renderer).not.toHaveBeenCalled();
+        expect(readySpy).toHaveBeenCalled();
+    });
+    it('should send a READY message with the correct payload', async () => {
+        const sendAsyncSpy = jest
+            .spyOn(PostMessageController.getInstance(), 'sendAsync')
+            .mockResolvedValue({});
+        await clientInstance.ready('web');
+        expect(sendAsyncSpy).toHaveBeenCalledWith({
+            type: ClientEventType.READY,
+            payload: { version: '1.0.0', platform: 'web' },
+        });
+    });
+    it('should return the correct version', () => {
+        expect(clientInstance.version()).toBe('1.0.0');
+    });
+    it('should return isPlatformNative from PostMessageController', () => {
+        const isPlatformNativeSpy = jest
+            .spyOn(PostMessageController.getInstance(), 'isPlatformNative')
+            .mockReturnValue(true);
+        expect(clientInstance.isPlatformNative()).toBe(true);
+        expect(isPlatformNativeSpy).toHaveBeenCalled();
+    });
+    it('should return isPlatformWeb from PostMessageController', () => {
+        const isPlatformWebSpy = jest.spyOn(PostMessageController.getInstance(), 'isPlatformWeb').mockReturnValue(true);
+        expect(clientInstance.isPlatformWeb()).toBe(true);
+        expect(isPlatformWebSpy).toHaveBeenCalled();
+    });
+    it('should return isOpenedFromXBees from PostMessageController', () => {
+        const isOpenedFromXBeesSpy = jest
+            .spyOn(PostMessageController.getInstance(), 'isOpenedFromXBees')
+            .mockReturnValue(true);
+        expect(clientInstance.isOpenedFromXBees()).toBe(true);
+        expect(isOpenedFromXBeesSpy).toHaveBeenCalled();
+    });
+    it('should get user PBX token from ClientParams', () => {
+        const userToken = 'token';
+        jest.spyOn(ClientParams.getInstance(), 'userToken', 'get').mockReturnValue(userToken);
+        expect(clientInstance.getUserPbxToken()).toBe(userToken);
+    });
+    it('should get user email from ClientParams', () => {
+        const userEmail = 'email@example.com';
+        jest.spyOn(ClientParams.getInstance(), 'userEmail', 'get').mockReturnValue(userEmail);
+        expect(clientInstance.getUserEmail()).toBe(userEmail);
+    });
+    it('should get referrer from ClientParams', () => {
+        const referrer = 'http://example.com';
+        jest.spyOn(ClientParams.getInstance(), 'referrer', 'get').mockReturnValue(referrer);
+        expect(clientInstance.getReferrer()).toBe(referrer);
+    });
+    it('should return correct back to app URL for native platform', () => {
+        jest.spyOn(ClientParams.getInstance(), 'iframeId', 'get').mockReturnValue('1234');
+        jest.spyOn(clientInstance, 'isPlatformNative').mockReturnValue(true);
+        expect(clientInstance.getBackToAppUrl()).toBe('com.wildix.rnc://integrations/1234');
+    });
+    it('should return correct back to app URL for web platform', () => {
+        jest.spyOn(ClientParams.getInstance(), 'iframeId', 'get').mockReturnValue('1234');
+        jest.spyOn(ClientParams.getInstance(), 'referrer', 'get').mockReturnValue('http://example.com');
+        jest.spyOn(clientInstance, 'isPlatformNative').mockReturnValue(false);
+        expect(clientInstance.getBackToAppUrl()).toBe('http://example.com/integrations/1234');
+    });
+    it('should return isDataOnly correctly', () => {
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('no-ui');
+        expect(clientInstance.isDataOnly()).toBe(true);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('daemon');
+        expect(clientInstance.isDataOnly()).toBe(true);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('d');
+        expect(clientInstance.isDataOnly()).toBe(false);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('dialog');
+        expect(clientInstance.isDataOnly()).toBe(false);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('ui');
+        expect(clientInstance.isDataOnly()).toBe(false);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('info-frame');
+        expect(clientInstance.isDataOnly()).toBe(false);
+    });
+    it('should return isSetupDialog correctly', () => {
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('d');
+        expect(clientInstance.isSetupDialog()).toBe(true);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('dialog');
+        expect(clientInstance.isSetupDialog()).toBe(true);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('no-ui');
+        expect(clientInstance.isSetupDialog()).toBe(false);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('daemon');
+        expect(clientInstance.isSetupDialog()).toBe(false);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('ui');
+        expect(clientInstance.isDataOnly()).toBe(false);
+        jest.spyOn(ClientParams.getInstance(), 'variant', 'get').mockReturnValue('info-frame');
+        expect(clientInstance.isDataOnly()).toBe(false);
+    });
+    it('should return showsUi correctly', () => {
+        jest.spyOn(clientInstance, 'isDataOnly').mockReturnValue(false);
+        expect(clientInstance.showsUi()).toBe(true);
+        jest.spyOn(clientInstance, 'isDataOnly').mockReturnValue(true);
+        expect(clientInstance.showsUi()).toBe(false);
+    });
+    it('should return isActivationOnly correctly', () => {
+        jest.spyOn(ClientParams.getInstance(), 'needAuthorize', 'get').mockReturnValue(true);
+        expect(clientInstance.isActivationOnly()).toBe(true);
+        jest.spyOn(ClientParams.getInstance(), 'needAuthorize', 'get').mockReturnValue(false);
+        expect(clientInstance.isActivationOnly()).toBe(false);
+    });
+    it('should add event listener through MessageListener', () => {
+        const eventName = EventType.PBX_TOKEN;
+        const callback = jest.fn();
+        clientInstance.addEventListener(eventName, callback);
+        expect(MessageListener.getInstance().listen).toHaveBeenCalledWith(eventName, callback);
+    });
+    it('should remove event listener through MessageListener', () => {
+        const eventName = EventType.PBX_TOKEN;
+        const callback = jest.fn();
+        clientInstance.removeEventListener(eventName, callback);
+        expect(MessageListener.getInstance().off).toHaveBeenCalledWith(eventName, callback);
+    });
+    it('should handle onRedirectQuery correctly', () => {
+        const callback = jest.fn();
+        clientInstance.onRedirectQuery(callback);
+        expect(MessageListener.getInstance().listen).toHaveBeenCalledWith(EventType.REDIRECT_QUERY, callback);
+    });
+    it('should handle onCallEnded correctly', () => {
+        const callback = jest.fn();
+        clientInstance.onCallEnded(callback);
+        expect(MessageListener.getInstance().listen).toHaveBeenCalledWith(EventType.TERMINATE_CALL, callback);
+    });
+    it('should handle onCallStarted correctly', () => {
+        const callback = jest.fn();
+        clientInstance.onCallStarted(callback);
+        expect(MessageListener.getInstance().listen).toHaveBeenCalledWith(EventType.ADD_CALL, callback);
+    });
+    it('should handle onPbxTokenChange correctly', () => {
+        const callback = jest.fn();
+        clientInstance.onPbxTokenChange(callback);
+        expect(MessageListener.getInstance().listen).toHaveBeenCalledWith(EventType.PBX_TOKEN, callback);
+    });
+    it('should handle getXBeesToken correctly', async () => {
+        const sendAsyncSpy = jest
+            .spyOn(PostMessageController.getInstance(), 'sendAsync')
+            .mockResolvedValue({});
+        await clientInstance.getXBeesToken();
+        expect(sendAsyncSpy).toHaveBeenCalledWith({ type: ClientEventType.TOKEN });
+    });
+    it('should handle onSuggestContacts correctly', () => {
+        const callback = jest.fn();
+        const addEventListenerSpy = jest.spyOn(clientInstance, 'addEventListener');
+        clientInstance.onSuggestContacts(callback);
+        expect(PostMessageController.getInstance().sendAsyncErrorSafe).toHaveBeenCalledWith({
+            type: ClientEventType.CONTACTS_AUTO_SUGGEST_IS_SUPPORTED,
+        });
+        expect(addEventListenerSpy).toHaveBeenCalledWith(EventType.GET_CONTACTS_AUTO_SUGGEST, expect.any(Function));
+    });
+    it('should handle onLookupAndMatchContact correctly', () => {
+        const callback = jest.fn();
+        const addEventListenerSpy = jest.spyOn(clientInstance, 'addEventListener');
+        clientInstance.onLookupAndMatchContact(callback);
+        expect(PostMessageController.getInstance().sendAsyncErrorSafe).toHaveBeenCalledWith({
+            type: ClientEventType.CONTACT_LOOK_UP_AND_MATCH_IS_SUPPORTED,
+        });
+        expect(addEventListenerSpy).toHaveBeenCalledWith(EventType.GET_LOOK_UP_AND_MATCH, expect.any(Function));
+    });
+    it('should handle onThemeChange correctly', () => {
+        const callback = jest.fn();
+        clientInstance.onThemeChange(callback);
+        expect(MessageListener.getInstance().listen).toHaveBeenCalledWith(EventType.USE_THEME, callback);
+    });
+    it('should handle storage correctly', () => {
+        const key = 'testKey';
+        const value = 'testValue';
+        const localStorageManager = LocalStorageManager.getInstance();
+        clientInstance.saveToStorage(key, value);
+        expect(localStorageManager.save).toHaveBeenCalledWith(key, value);
+        clientInstance.deleteFromStorage(key);
+        expect(localStorageManager.delete).toHaveBeenCalledWith(key);
+        jest.spyOn(localStorageManager, 'retrieve').mockReturnValue(value);
+        expect(clientInstance.getFromStorage(key)).toBe(value);
+    });
+    it('should handle onStorage correctly', () => {
+        const callback = jest.fn();
+        clientInstance.onStorage(callback);
+        expect(LocalStorageManager.getInstance().onStorage).toHaveBeenCalledWith(callback);
+    });
+    it('should handle onLogout correctly', () => {
+        const callback = jest.fn();
+        clientInstance.onLogout(callback);
+        expect(PostMessageController.getInstance().sendAsync).toHaveBeenCalledWith({
+            type: ClientEventType.LOGOUT_IS_SUPPORTED,
+        });
+        expect(MessageListener.getInstance().listen).toHaveBeenCalledWith(EventType.LOGOUT, callback);
+    });
+    it('should handle sendAnalytics correctly', () => {
+        const eventName = 'testEvent';
+        const params = { key: 'value' };
+        clientInstance.sendAnalytics(eventName, params);
+        expect(PostMessageController.getInstance().sendAsync).toHaveBeenCalledWith({
+            type: ClientEventType.SEND_ANALYTICS,
+            payload: {
+                eventName,
+                params,
+            },
+        });
+    });
+    it('should set integration storage key correctly', () => {
+        const integrationKey = 'integrationKey';
+        clientInstance.setIntegrationStorageKey(integrationKey);
+        expect(LocalStorageManager.getInstance().setIntegrationKey).toHaveBeenCalledWith(integrationKey);
+    });
+    it('should get TechnicalSupport instance', () => {
+        expect(clientInstance.getTechnicalSupport()).toBe(TechnicalSupport.getInstance());
+    });
+});

package/dist-es/src/__tests__/MessageListener.test.js

@@ -0,0 +1,100 @@
+import { EventType } from '../enums';
+import { MessageListener } from '../helpers/MessageListener';
+describe('MessageListener', () => {
+    let listenerInstance;
+    let originalWindow;
+    beforeAll(() => {
+        originalWindow = { ...globalThis.window };
+    });
+    beforeEach(() => {
+        MessageListener.instance = null;
+        listenerInstance = MessageListener.getInstance();
+        jest.clearAllMocks();
+        // (listenerInstance as any).listeners = [];
+        // (listenerInstance as any).useSubscription = false;
+        globalThis.window = {
+            ...originalWindow,
+            addEventListener: jest.fn(),
+            removeEventListener: jest.fn(),
+            location: { host: 'http://example.com' },
+        };
+    });
+    afterAll(() => {
+        globalThis.window = originalWindow;
+    });
+    it('should return a singleton instance', () => {
+        const instance1 = MessageListener.getInstance();
+        const instance2 = MessageListener.getInstance();
+        expect(instance1).toBe(instance2);
+    });
+    it('should add an event listener and call the callback on message event', () => {
+        const mockCallback = jest.fn();
+        listenerInstance.listen(EventType.REDIRECT_QUERY, mockCallback);
+        // console.log((listenerInstance as any).listeners);
+        const messageEvent = {
+            data: JSON.stringify({ type: EventType.REDIRECT_QUERY, payload: { some: 'data' } }),
+            origin: 'http://parent.example.com',
+            source: {},
+        };
+        listenerInstance.onMessage(messageEvent);
+        expect(mockCallback).toHaveBeenCalledWith({ some: 'data' });
+    });
+    it('should not call the callback if the message origin is the same as the current window location', () => {
+        const mockCallback = jest.fn();
+        listenerInstance.listen(EventType.ADD_CALL, mockCallback);
+        const messageEvent = {
+            data: JSON.stringify({ type: EventType.ADD_CALL, payload: { some: 'data' } }),
+            origin: window.location.host,
+            source: window,
+        };
+        listenerInstance.onMessage(messageEvent);
+        expect(mockCallback).not.toHaveBeenCalled();
+    });
+    it('should remove an event listener and stop calling the callback on message event', () => {
+        const mockCallback = jest.fn();
+        const removeEventListener = listenerInstance.listen(EventType.ADD_CALL, mockCallback);
+        removeEventListener();
+        const messageEvent = {
+            data: JSON.stringify({ type: EventType.ADD_CALL, payload: { some: 'data' } }),
+            origin: 'http://example.com',
+            source: window,
+        };
+        listenerInstance.onMessage(messageEvent);
+        expect(mockCallback).not.toHaveBeenCalled();
+    });
+    it('should not add duplicate event listeners', () => {
+        const mockCallback = jest.fn();
+        listenerInstance.listen(EventType.ADD_CALL, mockCallback);
+        listenerInstance.listen(EventType.ADD_CALL, mockCallback);
+        expect(listenerInstance.listeners.length).toBe(1);
+    });
+    it('should parse valid JSON message data correctly', () => {
+        const validJsonMessage = '{"type": "xBeesAddCall", "payload": {"some": "data"}}';
+        const parsedMessage = listenerInstance.parseJSON(validJsonMessage);
+        expect(parsedMessage).toEqual({ type: EventType.ADD_CALL, payload: { some: 'data' } });
+    });
+    it('should return null for invalid JSON message data', () => {
+        const invalidJsonMessage = 'invalid json';
+        const parsedMessage = listenerInstance.parseJSON(invalidJsonMessage);
+        expect(parsedMessage).toBeNull();
+    });
+    it('should handle non-JSON message data gracefully', () => {
+        const messageEvent = {
+            data: 'invalid json',
+            origin: 'http://example.com',
+            source: window,
+        };
+        expect(listenerInstance.parseMessage(messageEvent)).toBeNull();
+    });
+    it('should correctly manage the useSubscription flag and event listeners on window', () => {
+        const mockCallback = jest.fn();
+        const addEventListenerSpy = jest.spyOn(window, 'addEventListener');
+        const removeEventListenerSpy = jest.spyOn(window, 'removeEventListener');
+        const removeEventListener = listenerInstance.listen(EventType.ADD_CALL, mockCallback);
+        expect(listenerInstance.useSubscription).toBe(true);
+        expect(addEventListenerSpy).toHaveBeenCalledWith('message', expect.any(Function));
+        removeEventListener();
+        expect(listenerInstance.useSubscription).toBe(false);
+        expect(removeEventListenerSpy).toHaveBeenCalledWith('message', expect.any(Function));
+    });
+});

package/dist-es/src/helpers/MessageListener.js

@@ -33,14 +33,17 @@ export class MessageListener {
     }
     onMessage = (message) => {
         if (window.location.host === message.origin || window === message.source) {
+            console.debug(`onMessage skipped ${window.location.host} - ${message.origin} - ${window === message.source} - ${message}`);
             // skip events started from integration itself if any
             return;
         }
         const data = this.parseMessage(message);
         if (!data) {
+            console.debug('onMessage skipped', message);
             return;
         }
         const { type, payload } = data;
+        console.debug(`onMessage call - ${type} - ${payload}`);
         this.listeners.forEach(({ eventName, callback }) => {
             if (eventName === type) {
                 if (type === EventType.ADD_CALL) {
@@ -55,7 +58,7 @@ export class MessageListener {
             }
         });
     };
-    addEventListener(eventName, callback) {
+    listen(eventName, callback) {
         if (!this.useSubscription) {
             this.useSubscription = true;
             window.addEventListener('message', this.onMessage);
@@ -65,10 +68,10 @@ export class MessageListener {
             this.listeners.push({ eventName, callback });
         }
         return () => {
-            this.removeEventListener(eventName, callback);
+            this.off(eventName, callback);
         };
     }
-    removeEventListener(eventName, callback) {
+    off(eventName, callback) {
         this.listeners = this.listeners.filter(({ eventName: _eventName, callback: _callback }) => !(Object.is(callback, _callback) && (!eventName ? true : eventName === _eventName)));
         if (this.useSubscription && !this.listeners.length) {
             this.useSubscription = false;

package/dist-types/src/__tests__/Client.test.d.ts

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

package/dist-types/src/__tests__/MessageListener.test.d.ts

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

package/dist-types/src/helpers/MessageListener.d.ts

@@ -10,6 +10,6 @@ export declare class MessageListener {
     private parseMessage;
     private parseJSON;
     private onMessage;
-    addEventListener<T extends EventType = EventType>(eventName: T, callback: Callback<T>): RemoveEventListener;
-    removeEventListener<T extends EventType = EventType>(eventName: T | null, callback: Callback<T>): void;
+    listen<T extends EventType = EventType>(eventName: T, callback: Callback<T>): RemoveEventListener;
+    off<T extends EventType = EventType>(eventName: T | null, callback: Callback<T>): void;
 }

package/dist-types/types/Event.d.ts

@@ -19,4 +19,4 @@ export type EventCallbackMap = {
     [EventType.PBX_TOKEN]: (token: EventPayloadMap[EventType.PBX_TOKEN]) => void;
     [EventType.REDIRECT_QUERY]: (query: EventPayloadMap[EventType.REDIRECT_QUERY]) => void;
 };
-export type RawMessageEvent = MessageEvent<'string' | Message>;
+export type RawMessageEvent = MessageEvent<string | Message>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wildix/xbees-connect",
-  "version": "1.2.0-alpha.4",
+  "version": "1.2.0-alpha.8",
   "description": "This library provides easy communication between x-bees and integrated web applications",
   "author": "dimitri.chernykh <dimitri.chernykh@wildix.com>",
   "homepage": "",
@@ -17,7 +17,10 @@
     "build:docs": "typedoc",
     "lint": "eslint . && tsc --noEmit",
     "lint:fix": "eslint . --fix",
-    "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo"
+    "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
   },
   "files": [
     "dist-*/**"
@@ -30,8 +33,12 @@
     "access": "public"
   },
   "devDependencies": {
+    "@types/jest": "^29.5.12",
     "eslint": "^8.55.0",
+    "eslint-plugin-jest": "^28.5.0",
+    "jest": "^29.7.0",
     "rimraf": "^5.0.5",
+    "ts-jest": "^29.1.3",
     "typescript": "^5.3.3"
   },
   "parserOptions": {
@@ -42,5 +49,5 @@
   "engines": {
     "node": ">=16"
   },
-  "gitHead": "9b2373d5205d394e554be89f5001d14105322995"
+  "gitHead": "c69a81d27e17a11fdcd05d9b24eb504ee348d40c"
 }