@futdevpro/fsm-dynamo 1.16.37 → 1.16.39

package/build/_modules/data-handler/_models/data-list-handler.control-model.js

@@ -1,224 +1,224 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyFM_DataListHandler = void 0;
-const rxjs_1 = require("rxjs");
-const data_handler_control_model_1 = require("./data-handler.control-model");
-const error_control_model_1 = require("../../../_models/control-models/error.control-model");
-const log_util_1 = require("../../../_collections/utils/log.util");
-/**
- * A specialized data handler for managing arrays of data items.
- * Extends DyFM_DataHandler to provide additional functionality for handling lists of data.
- *
- * @template T_DataList - The type of the data list (must be an array of T_DataItem)
- * @template T_DependencyData - The type of dependency data (defaults to any)
- * @template T_DataLoadBy - The type used to identify how data should be loaded (defaults to string)
- * @template T_DataItem - The type of individual items in the list (must extend DyFM_Metadata)
- *
- * @example
- * ```typescript
- * // Create a data list handler for user messages
- * const messagesHandler = new DyFM_DataListHandler<UserMessage[]>({
- *   get: async (userId: string): Promise<UserMessage[]> => {
- *     return await userApiService.getUserMessages(userId, 0, 100);
- *   }
- * });
- *
- * // Access the data list
- * const messages = messagesHandler.dataList;
- *
- * // Add a new message
- * messagesHandler.addItem(newMessage);
- *
- * // Update an existing message
- * messagesHandler.updateItem(updatedMessage);
- *
- * // Subscribe to changes
- * messagesHandler.dataList$.subscribe(messages => {
- *   console.log('Messages updated:', messages);
- * });
- * ```
- */
-class DyFM_DataListHandler extends data_handler_control_model_1.DyFM_DataHandler {
-    setItem;
-    deleteItem;
-    /**
-     * BehaviorSubject that holds the current data list.
-     * Computed from the base data_BS BehaviorSubject, ensuring it always returns an array.
-     */
-    dataList_BS;
-    /**
-     * Observable that holds the current data list.
-     * Computed from the base data$ Observable, ensuring it always returns an array.
-     */
-    dataList$;
-    /**
-     * BehaviorSubject that holds the currently active item.
-     */
-    activeItem_BS;
-    /**
-     * Observable that holds the currently active item.
-     */
-    activeItem$;
-    /**
-     * Gets the current data list.
-     * @returns The current array of data items
-     */
-    get data() {
-        return this.dataList_BS.value;
-    }
-    /**
-     * Gets the current data list.
-     * Alias for data getter.
-     * @returns The current array of data items
-     */
-    get dataList() {
-        return this.dataList_BS.value;
-    }
-    /**
-     * Creates a new instance of DyFM_DataListHandler.
-     *
-     * @param set - Configuration settings for the data handler
-     * @param skipDependencyConnections - Optional flag to skip dependency connections during construction
-     */
-    constructor(set, 
-    /** is in construct?
-     * so the dependent data handlers are not added here, but in the extended class */
-    skipDependencyConnections) {
-        super(set, skipDependencyConnections);
-        // Initialize dataList BehaviorSubject and Observable
-        this.dataList_BS = new rxjs_1.BehaviorSubject([]);
-        this.dataList$ = this.dataList_BS.asObservable();
-        // Initialize activeItem BehaviorSubject and Observable
-        this.activeItem_BS = new rxjs_1.BehaviorSubject(null);
-        this.activeItem$ = this.activeItem_BS.asObservable();
-        // Subscribe to data changes to update dataList
-        this.data$.subscribe(data => {
-            const dataList = Array.isArray(data) ? data : [];
-            this.dataList_BS.next(dataList);
-        });
-        if (set.setItem) {
-            this.setItem = set.setItem;
-        }
-        if (set.deleteItem) {
-            this.deleteItem = set.deleteItem;
-        }
-        this.getPostProcesses.push((data) => {
-            // check if data is an array
-            if (!Array.isArray(data)) {
-                console.error(`DYNAMO DataListHandler (${this.name}) ERROR: ` +
-                    `\nData is not an array!:` +
-                    '\n\n', data);
-                throw new Error(`Data is not an array! (${this.name})`);
-            }
-            return data;
-        });
-        if (!skipDependencyConnections) {
-            if (set.dependencyDataHandler) {
-                this.addDependencyDataHandler(set.dependencyDataHandler);
-            }
-            if (set.dependentDataHandlers) {
-                this.addDependentDataHandlers(set.dependentDataHandlers, true);
-            }
-        }
-    }
-    async reloadData(loadBy) {
-        try {
-            const setActiveItem = !this.activeItem_BS.value || this.activeItem_BS.value?._id !== loadBy;
-            const dataList = await super.reloadData(loadBy);
-            if (setActiveItem && dataList.length > 0) {
-                this.setActiveItem(dataList[0]);
-            }
-            return dataList;
-        }
-        catch (error) {
-            log_util_1.DyFM_Log.error(`Error reloading DyFM_DataListHandler (${this.name}):`, error);
-            throw error;
-        }
-    }
-    clear(dontClearDependents) {
-        super.clear(dontClearDependents);
-        this.activeItem_BS.next(null);
-    }
-    /**
-     * Adds a new item to the data list.
-     *
-     * @param item - The item to add to the list
-     * @param updateBy - Optional parameter for update tracking
-     * @param dontSendUpdate - Optional flag to prevent sending update notification
-     */
-    async addItem(item, updateBy, dontSendUpdate) {
-        const currentData = this.data;
-        currentData.push(item);
-        if (this.setItem && !dontSendUpdate) {
-            await this.setItem(item, updateBy);
-            // dont send update because we already sent it to the setItem function
-            await this.updateData(this.dataList_BS.value, true);
-        }
-        else {
-            await this.updateData(this.dataList_BS.value, dontSendUpdate);
-        }
-        this.activeItem_BS.next(item);
-    }
-    /**
-     * Removes an item from the data list.
-     * The item is identified by its _id property.
-     *
-     * @param id - The id of the item to remove from the list
-     * @param updateBy - Optional parameter for update tracking
-     * @param dontSendUpdate - Optional flag to prevent sending update notification
-     */
-    async removeItem(id, updateBy, dontSendUpdate) {
-        const currentData = this.data;
-        const index = currentData.findIndex(i => i._id === id);
-        if (index !== -1) {
-            currentData.splice(index, 1);
-            if (this.deleteItem) {
-                await this.deleteItem(id, updateBy);
-                await this.updateData(this.dataList_BS.value, true);
-            }
-            else {
-                await this.updateData(this.dataList_BS.value, dontSendUpdate);
-            }
-        }
-        if (this.activeItem_BS.value?._id === id) {
-            this.activeItem_BS.next(null);
-        }
-    }
-    /**
-     * Updates an existing item in the data list.
-     * The item is identified by its _id property.
-     *
-     * @param item - The updated item
-     * @param updateBy - Optional parameter for update tracking
-     * @param dontSendUpdate - Optional flag to prevent sending update notification
-     * @throws Error if the item is not found in the list
-     */
-    async updateItem(item, updateBy, dontSendUpdate) {
-        const currentData = this.data;
-        const index = currentData.findIndex(i => i._id === item._id);
-        if (index !== -1) {
-            currentData[index] = item;
-            if (this.setItem) {
-                await this.setItem(item, updateBy);
-                await this.updateData(this.dataList_BS.value, true);
-            }
-            else {
-                await this.updateData(this.dataList_BS.value, dontSendUpdate);
-            }
-        }
-        else {
-            throw new error_control_model_1.DyFM_Error({
-                error: new Error(`Item not found! (${this.name})`),
-                errorCode: 'DyFM-DLH-UI1',
-                additionalContent: {
-                    item: item,
-                },
-            });
-        }
-    }
-    setActiveItem(item) {
-        this.activeItem_BS.next(item);
-    }
-}
-exports.DyFM_DataListHandler = DyFM_DataListHandler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyFM_DataListHandler = void 0;
+const rxjs_1 = require("rxjs");
+const data_handler_control_model_1 = require("./data-handler.control-model");
+const error_control_model_1 = require("../../../_models/control-models/error.control-model");
+const log_util_1 = require("../../../_collections/utils/log.util");
+/**
+ * A specialized data handler for managing arrays of data items.
+ * Extends DyFM_DataHandler to provide additional functionality for handling lists of data.
+ *
+ * @template T_DataList - The type of the data list (must be an array of T_DataItem)
+ * @template T_DependencyData - The type of dependency data (defaults to any)
+ * @template T_DataLoadBy - The type used to identify how data should be loaded (defaults to string)
+ * @template T_DataItem - The type of individual items in the list (must extend DyFM_Metadata)
+ *
+ * @example
+ * ```typescript
+ * // Create a data list handler for user messages
+ * const messagesHandler = new DyFM_DataListHandler<UserMessage[]>({
+ *   get: async (userId: string): Promise<UserMessage[]> => {
+ *     return await userApiService.getUserMessages(userId, 0, 100);
+ *   }
+ * });
+ *
+ * // Access the data list
+ * const messages = messagesHandler.dataList;
+ *
+ * // Add a new message
+ * messagesHandler.addItem(newMessage);
+ *
+ * // Update an existing message
+ * messagesHandler.updateItem(updatedMessage);
+ *
+ * // Subscribe to changes
+ * messagesHandler.dataList$.subscribe(messages => {
+ *   console.log('Messages updated:', messages);
+ * });
+ * ```
+ */
+class DyFM_DataListHandler extends data_handler_control_model_1.DyFM_DataHandler {
+    setItem;
+    deleteItem;
+    /**
+     * BehaviorSubject that holds the current data list.
+     * Computed from the base data_BS BehaviorSubject, ensuring it always returns an array.
+     */
+    dataList_BS;
+    /**
+     * Observable that holds the current data list.
+     * Computed from the base data$ Observable, ensuring it always returns an array.
+     */
+    dataList$;
+    /**
+     * BehaviorSubject that holds the currently active item.
+     */
+    activeItem_BS;
+    /**
+     * Observable that holds the currently active item.
+     */
+    activeItem$;
+    /**
+     * Gets the current data list.
+     * @returns The current array of data items
+     */
+    get data() {
+        return this.dataList_BS.value;
+    }
+    /**
+     * Gets the current data list.
+     * Alias for data getter.
+     * @returns The current array of data items
+     */
+    get dataList() {
+        return this.dataList_BS.value;
+    }
+    /**
+     * Creates a new instance of DyFM_DataListHandler.
+     *
+     * @param set - Configuration settings for the data handler
+     * @param skipDependencyConnections - Optional flag to skip dependency connections during construction
+     */
+    constructor(set, 
+    /** is in construct?
+     * so the dependent data handlers are not added here, but in the extended class */
+    skipDependencyConnections) {
+        super(set, skipDependencyConnections);
+        // Initialize dataList BehaviorSubject and Observable
+        this.dataList_BS = new rxjs_1.BehaviorSubject([]);
+        this.dataList$ = this.dataList_BS.asObservable();
+        // Initialize activeItem BehaviorSubject and Observable
+        this.activeItem_BS = new rxjs_1.BehaviorSubject(null);
+        this.activeItem$ = this.activeItem_BS.asObservable();
+        // Subscribe to data changes to update dataList
+        this.data$.subscribe(data => {
+            const dataList = Array.isArray(data) ? data : [];
+            this.dataList_BS.next(dataList);
+        });
+        if (set.setItem) {
+            this.setItem = set.setItem;
+        }
+        if (set.deleteItem) {
+            this.deleteItem = set.deleteItem;
+        }
+        this.getPostProcesses.push((data) => {
+            // check if data is an array
+            if (!Array.isArray(data)) {
+                console.error(`DYNAMO DataListHandler (${this.name}) ERROR: ` +
+                    `\nData is not an array!:` +
+                    '\n\n', data);
+                throw new Error(`Data is not an array! (${this.name})`);
+            }
+            return data;
+        });
+        if (!skipDependencyConnections) {
+            if (set.dependencyDataHandler) {
+                this.addDependencyDataHandler(set.dependencyDataHandler);
+            }
+            if (set.dependentDataHandlers) {
+                this.addDependentDataHandlers(set.dependentDataHandlers, true);
+            }
+        }
+    }
+    async reloadData(loadBy) {
+        try {
+            const setActiveItem = !this.activeItem_BS.value || this.activeItem_BS.value?._id !== loadBy;
+            const dataList = await super.reloadData(loadBy);
+            if (setActiveItem && dataList.length > 0) {
+                this.setActiveItem(dataList[0]);
+            }
+            return dataList;
+        }
+        catch (error) {
+            log_util_1.DyFM_Log.error(`Error reloading DyFM_DataListHandler (${this.name}):`, error);
+            throw error;
+        }
+    }
+    clear(dontClearDependents) {
+        super.clear(dontClearDependents);
+        this.activeItem_BS.next(null);
+    }
+    /**
+     * Adds a new item to the data list.
+     *
+     * @param item - The item to add to the list
+     * @param updateBy - Optional parameter for update tracking
+     * @param dontSendUpdate - Optional flag to prevent sending update notification
+     */
+    async addItem(item, updateBy, dontSendUpdate) {
+        const currentData = this.data;
+        currentData.push(item);
+        if (this.setItem && !dontSendUpdate) {
+            await this.setItem(item, updateBy);
+            // dont send update because we already sent it to the setItem function
+            await this.updateData(this.dataList_BS.value, true);
+        }
+        else {
+            await this.updateData(this.dataList_BS.value, dontSendUpdate);
+        }
+        this.activeItem_BS.next(item);
+    }
+    /**
+     * Removes an item from the data list.
+     * The item is identified by its _id property.
+     *
+     * @param id - The id of the item to remove from the list
+     * @param updateBy - Optional parameter for update tracking
+     * @param dontSendUpdate - Optional flag to prevent sending update notification
+     */
+    async removeItem(id, updateBy, dontSendUpdate) {
+        const currentData = this.data;
+        const index = currentData.findIndex(i => i._id === id);
+        if (index !== -1) {
+            currentData.splice(index, 1);
+            if (this.deleteItem) {
+                await this.deleteItem(id, updateBy);
+                await this.updateData(this.dataList_BS.value, true);
+            }
+            else {
+                await this.updateData(this.dataList_BS.value, dontSendUpdate);
+            }
+        }
+        if (this.activeItem_BS.value?._id === id) {
+            this.activeItem_BS.next(null);
+        }
+    }
+    /**
+     * Updates an existing item in the data list.
+     * The item is identified by its _id property.
+     *
+     * @param item - The updated item
+     * @param updateBy - Optional parameter for update tracking
+     * @param dontSendUpdate - Optional flag to prevent sending update notification
+     * @throws Error if the item is not found in the list
+     */
+    async updateItem(item, updateBy, dontSendUpdate) {
+        const currentData = this.data;
+        const index = currentData.findIndex(i => i._id === item._id);
+        if (index !== -1) {
+            currentData[index] = item;
+            if (this.setItem) {
+                await this.setItem(item, updateBy);
+                await this.updateData(this.dataList_BS.value, true);
+            }
+            else {
+                await this.updateData(this.dataList_BS.value, dontSendUpdate);
+            }
+        }
+        else {
+            throw new error_control_model_1.DyFM_Error({
+                error: new Error(`Item not found! (${this.name})`),
+                errorCode: 'DyFM-DLH-UI1',
+                additionalContent: {
+                    item: item,
+                },
+            });
+        }
+    }
+    setActiveItem(item) {
+        this.activeItem_BS.next(item);
+    }
+}
+exports.DyFM_DataListHandler = DyFM_DataListHandler;
 //# sourceMappingURL=data-list-handler.control-model.js.map

package/build/_modules/data-handler/_models/data-list-handler.control-model.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data-list-handler.control-model.spec.d.ts.map

package/build/_modules/data-handler/_models/data-list-handler.control-model.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-list-handler.control-model.spec.d.ts","sourceRoot":"","sources":["../../../../src/_modules/data-handler/_models/data-list-handler.control-model.spec.ts"],"names":[],"mappings":""}

package/build/_modules/data-handler/_models/data-list-handler.control-model.spec.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const data_list_handler_control_model_1 = require("./data-list-handler.control-model");
+const metadata_data_model_1 = require("../../../_models/data-models/metadata.data-model");
+class TestMetadata extends metadata_data_model_1.DyFM_Metadata {
+    name;
+}
+describe('| DyFM_DataListHandler', () => {
+    let handler;
+    let settings;
+    beforeEach(() => {
+        settings = {
+            name: 'TestListHandler',
+            get: async (loadBy) => {
+                return [
+                    { _id: '1', name: 'item1' },
+                    { _id: '2', name: 'item2' },
+                ];
+            },
+            setItem: async (item) => item,
+            deleteItem: async (id) => { },
+            defaultValue: [],
+        };
+        handler = new data_list_handler_control_model_1.DyFM_DataListHandler(settings);
+    });
+    it('| should create an instance with settings', () => {
+        expect(handler).toBeTruthy();
+        expect(handler.name).toBe('TestListHandler');
+    });
+    it('| should have dataList$ observable', () => {
+        expect(handler.dataList$).toBeTruthy();
+    });
+    it('| should have activeItem$ observable', () => {
+        expect(handler.activeItem$).toBeTruthy();
+    });
+    it('| should get empty dataList initially', () => {
+        expect(handler.dataList).toEqual([]);
+    });
+    it('| should add item to list', async () => {
+        const newItem = { _id: '3', name: 'item3' };
+        await handler.addItem(newItem);
+        expect(handler.dataList.length).toBeGreaterThan(0);
+    });
+    it('| should set active item', () => {
+        const item = { _id: '1', name: 'item1' };
+        handler.setActiveItem(item);
+        handler.activeItem$.subscribe(activeItem => {
+            expect(activeItem).toEqual(item);
+        });
+    });
+    it('| should clear data and active item', () => {
+        handler.clear();
+        expect(handler.dataList).toEqual([]);
+        handler.activeItem$.subscribe(activeItem => {
+            expect(activeItem).toBeNull();
+        });
+    });
+    it('| should remove item with deleteItem', async () => {
+        // Test case for lines 202-216: removeItem with deleteItem
+        await handler.reloadData('test');
+        const deleteItemSpy = spyOn(handler, 'deleteItem').and.returnValue(Promise.resolve());
+        await handler.removeItem('1');
+        expect(deleteItemSpy).toHaveBeenCalledWith('1', undefined);
+        expect(handler.dataList.find(i => i._id === '1')).toBeUndefined();
+    });
+    it('| should remove item without deleteItem', async () => {
+        // Test case for lines 202-216: removeItem without deleteItem
+        settings.deleteItem = undefined;
+        settings.noId = true;
+        handler = new data_list_handler_control_model_1.DyFM_DataListHandler(settings);
+        await handler.reloadData();
+        await handler.removeItem('1');
+        expect(handler.dataList.find(i => i._id === '1')).toBeUndefined();
+    });
+    it('| should clear active item when removing active item', async () => {
+        // Test case for lines 213-215: clear active item when removing
+        await handler.reloadData('test');
+        handler.setActiveItem(handler.dataList[0]);
+        await handler.removeItem(handler.dataList[0]._id);
+        handler.activeItem$.subscribe(activeItem => {
+            expect(activeItem).toBeNull();
+        });
+    });
+    it('| should update item with setItem', async () => {
+        // Test case for lines 228-247: updateItem with setItem
+        await handler.reloadData('test');
+        const setItemSpy = spyOn(handler, 'setItem').and.returnValue(Promise.resolve(handler.dataList[0]));
+        const updatedItem = { _id: '1', name: 'updated' };
+        await handler.updateItem(updatedItem);
+        expect(setItemSpy).toHaveBeenCalledWith(updatedItem, undefined);
+        expect(handler.dataList.find(i => i._id === '1')?.name).toBe('updated');
+    });
+    it('| should update item without setItem', async () => {
+        // Test case for lines 228-247: updateItem without setItem
+        settings.setItem = undefined;
+        settings.noId = true;
+        handler = new data_list_handler_control_model_1.DyFM_DataListHandler(settings);
+        await handler.reloadData();
+        const updatedItem = { _id: '1', name: 'updated' };
+        await handler.updateItem(updatedItem);
+        expect(handler.dataList.find(i => i._id === '1')?.name).toBe('updated');
+    });
+    it('| should throw error when updating non-existent item', async () => {
+        // Test case for lines 238-246: updateItem throws error when item not found
+        await handler.reloadData('test');
+        const nonExistentItem = { _id: '999', name: 'not found' };
+        await expectAsync(handler.updateItem(nonExistentItem)).toBeRejected();
+    });
+    it('| should reloadData and set active item when different', async () => {
+        // Test case for lines 153-166: reloadData override
+        await handler.reloadData('test');
+        handler.setActiveItem(handler.dataList[0]);
+        const newLoadBy = 'test2';
+        settings.get = async (loadBy) => {
+            return [
+                { _id: '3', name: 'item3' },
+                { _id: '4', name: 'item4' },
+            ];
+        };
+        handler = new data_list_handler_control_model_1.DyFM_DataListHandler(settings);
+        await handler.reloadData(newLoadBy);
+        expect(handler.activeItem_BS.value).toBeDefined();
+    });
+    it('| should reloadData and not set active item when same', async () => {
+        // Test case for lines 153-166: reloadData override with same loadBy
+        await handler.reloadData('test');
+        const originalActiveItem = handler.dataList[0];
+        handler.setActiveItem(originalActiveItem);
+        await handler.reloadData('test');
+        expect(handler.activeItem_BS.value).toEqual(originalActiveItem);
+    });
+    it('| should addItem with setItem and dontSendUpdate false', async () => {
+        // Test case for lines 180-191: addItem with setItem
+        await handler.reloadData('test');
+        const setItemSpy = spyOn(handler, 'setItem').and.returnValue(Promise.resolve({ _id: '3', name: 'item3' }));
+        const newItem = { _id: '3', name: 'item3' };
+        await handler.addItem(newItem, undefined, false);
+        expect(setItemSpy).toHaveBeenCalled();
+        expect(handler.activeItem_BS.value).toEqual(newItem);
+    });
+    it('| should addItem with setItem and dontSendUpdate true', async () => {
+        // Test case for lines 180-191: addItem with dontSendUpdate
+        // When dontSendUpdate is true, setItem should NOT be called (line 183: if (this.setItem && !dontSendUpdate))
+        await handler.reloadData('test');
+        const setItemSpy = spyOn(handler, 'setItem').and.returnValue(Promise.resolve({ _id: '3', name: 'item3' }));
+        const newItem = { _id: '3', name: 'item3' };
+        await handler.addItem(newItem, undefined, true);
+        expect(setItemSpy).not.toHaveBeenCalled();
+        expect(handler.activeItem_BS.value).toEqual(newItem);
+    });
+    it('| should addItem without setItem', async () => {
+        // Test case for lines 180-191: addItem without setItem
+        settings.setItem = undefined;
+        handler = new data_list_handler_control_model_1.DyFM_DataListHandler(settings);
+        await handler.reloadData('test');
+        const newItem = { _id: '3', name: 'item3' };
+        await handler.addItem(newItem);
+        expect(handler.dataList.find(i => i._id === '3')).toBeDefined();
+    });
+    it('| should removeItem when item not found', async () => {
+        // Test case for lines 201-216: removeItem when index === -1
+        await handler.reloadData('test');
+        await handler.removeItem('999');
+        // Should not throw, just do nothing
+        expect(handler.dataList.length).toBe(2);
+    });
+    it('| should removeItem with updateBy parameter', async () => {
+        // Test case for lines 201-216: removeItem with updateBy
+        await handler.reloadData('test');
+        const deleteItemSpy = spyOn(handler, 'deleteItem').and.returnValue(Promise.resolve());
+        await handler.removeItem('1', 'updateByValue');
+        expect(deleteItemSpy).toHaveBeenCalledWith('1', 'updateByValue');
+    });
+    it('| should removeItem with dontSendUpdate', async () => {
+        // Test case for lines 201-216: removeItem with dontSendUpdate
+        await handler.reloadData('test');
+        settings.deleteItem = undefined;
+        handler = new data_list_handler_control_model_1.DyFM_DataListHandler(settings);
+        await handler.reloadData('test');
+        await handler.removeItem('1', undefined, true);
+        expect(handler.dataList.find(i => i._id === '1')).toBeUndefined();
+    });
+    it('| should updateItem with updateBy parameter', async () => {
+        // Test case for lines 227-247: updateItem with updateBy
+        await handler.reloadData('test');
+        const setItemSpy = spyOn(handler, 'setItem').and.returnValue(Promise.resolve(handler.dataList[0]));
+        const updatedItem = { _id: '1', name: 'updated' };
+        await handler.updateItem(updatedItem, 'updateByValue');
+        expect(setItemSpy).toHaveBeenCalledWith(updatedItem, 'updateByValue');
+    });
+    it('| should updateItem with dontSendUpdate', async () => {
+        // Test case for lines 227-247: updateItem with dontSendUpdate
+        await handler.reloadData('test');
+        settings.setItem = undefined;
+        handler = new data_list_handler_control_model_1.DyFM_DataListHandler(settings);
+        await handler.reloadData('test');
+        const updatedItem = { _id: '1', name: 'updated' };
+        await handler.updateItem(updatedItem, undefined, true);
+        expect(handler.dataList.find(i => i._id === '1')?.name).toBe('updated');
+    });
+});
+//# sourceMappingURL=data-list-handler.control-model.spec.js.map