scandit-datacapture-frameworks-label 8.1.1 → 8.2.0

package/test/LabelCaptureAdaptiveRecognitionSettings.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect } from '@jest/globals';
+import { LabelCaptureAdaptiveRecognitionSettings } from '../src/labelcapture/LabelCaptureAdaptiveRecognitionSettings';
+import { AdaptiveRecognitionResultType } from '../src/labelcapture/AdaptiveRecognitionResultType';
+
+describe('LabelCaptureAdaptiveRecognitionSettings', () => {
+  describe('constructor', () => {
+    it('should create settings with resultType', () => {
+      const settings = new LabelCaptureAdaptiveRecognitionSettings(AdaptiveRecognitionResultType.Receipt);
+
+      expect(settings.resultType).toBe(AdaptiveRecognitionResultType.Receipt);
+    });
+
+    it('should have default empty processingHintText', () => {
+      const settings = new LabelCaptureAdaptiveRecognitionSettings(AdaptiveRecognitionResultType.Receipt);
+
+      expect(settings.processingHintText).toBe('');
+    });
+  });
+
+  describe('resultType', () => {
+    it('getter returns the correct value', () => {
+      const settings = new LabelCaptureAdaptiveRecognitionSettings(AdaptiveRecognitionResultType.Receipt);
+
+      expect(settings.resultType).toBe(AdaptiveRecognitionResultType.Receipt);
+    });
+
+    it('setter updates the value', () => {
+      const settings = new LabelCaptureAdaptiveRecognitionSettings(AdaptiveRecognitionResultType.Receipt);
+
+      // Currently only Receipt is available, but testing setter works
+      settings.resultType = AdaptiveRecognitionResultType.Receipt;
+
+      expect(settings.resultType).toBe(AdaptiveRecognitionResultType.Receipt);
+    });
+  });
+
+  describe('processingHintText', () => {
+    it('getter returns the correct value', () => {
+      const settings = new LabelCaptureAdaptiveRecognitionSettings(AdaptiveRecognitionResultType.Receipt);
+      settings.processingHintText = 'Processing...';
+
+      expect(settings.processingHintText).toBe('Processing...');
+    });
+
+    it('setter updates the value', () => {
+      const settings = new LabelCaptureAdaptiveRecognitionSettings(AdaptiveRecognitionResultType.Receipt);
+
+      settings.processingHintText = 'Please wait...';
+
+      expect(settings.processingHintText).toBe('Please wait...');
+    });
+
+    it('can be set to empty string', () => {
+      const settings = new LabelCaptureAdaptiveRecognitionSettings(AdaptiveRecognitionResultType.Receipt);
+      settings.processingHintText = 'Some text';
+      settings.processingHintText = '';
+
+      expect(settings.processingHintText).toBe('');
+    });
+
+    it('can contain special characters', () => {
+      const settings = new LabelCaptureAdaptiveRecognitionSettings(AdaptiveRecognitionResultType.Receipt);
+
+      settings.processingHintText = 'Processing... 处理中 🔄';
+
+      expect(settings.processingHintText).toBe('Processing... 处理中 🔄');
+    });
+
+    it('can contain newlines', () => {
+      const settings = new LabelCaptureAdaptiveRecognitionSettings(AdaptiveRecognitionResultType.Receipt);
+
+      settings.processingHintText = 'Line 1\nLine 2';
+
+      expect(settings.processingHintText).toBe('Line 1\nLine 2');
+    });
+  });
+
+  describe('serialization', () => {
+    it('should have nameForSerialization decorators applied', () => {
+      const settings = new LabelCaptureAdaptiveRecognitionSettings(AdaptiveRecognitionResultType.Receipt);
+      settings.processingHintText = 'Test hint';
+
+      // The class should be serializable via DefaultSerializeable
+      // Testing that the instance has the expected structure
+      expect(settings.resultType).toBeDefined();
+      expect(settings.processingHintText).toBeDefined();
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle very long processingHintText', () => {
+      const settings = new LabelCaptureAdaptiveRecognitionSettings(AdaptiveRecognitionResultType.Receipt);
+      const longText = 'A'.repeat(10000);
+
+      settings.processingHintText = longText;
+
+      expect(settings.processingHintText).toBe(longText);
+      expect(settings.processingHintText.length).toBe(10000);
+    });
+
+    it('should handle multiple updates to processingHintText', () => {
+      const settings = new LabelCaptureAdaptiveRecognitionSettings(AdaptiveRecognitionResultType.Receipt);
+
+      settings.processingHintText = 'First';
+      expect(settings.processingHintText).toBe('First');
+
+      settings.processingHintText = 'Second';
+      expect(settings.processingHintText).toBe('Second');
+
+      settings.processingHintText = 'Third';
+      expect(settings.processingHintText).toBe('Third');
+    });
+  });
+});
+

package/test/LabelCaptureValidationFlowOverlayController.test.ts

@@ -0,0 +1,427 @@
+import { describe, it, expect, jest, beforeEach, afterEach, beforeAll } from '@jest/globals';
+import { EventEmitter, EventPayload, FactoryMaker } from 'scandit-datacapture-frameworks-core';
+import { LabelCaptureValidationFlowOverlayController, LabelCaptureValidationFlowListenerEvents } from '../src/labelcapture/controller/LabelCaptureValidationFlowOverlayController';
+import { LabelCaptureValidationFlowOverlay } from '../src/labelcapture/view/LabelCaptureValidationFlowOverlay';
+import { LabelCaptureValidationFlowListener } from '../src/labelcapture/LabelCaptureValidationFlowListener';
+import { LabelField } from '../src/labelcapture/LabelField';
+import { LabelCapture } from '../src/labelcapture/LabelCapture';
+import { LabelCaptureSettings } from '../src/labelcapture/LabelCaptureSettings';
+import { LabelCaptureValidationFlowSettings } from '../src/labelcapture/LabelCaptureValidationFlowSettings';
+import { LabelCaptureDefaults } from '../src/defaults';
+
+// Mock defaults for tests
+const mockDefaults: LabelCaptureDefaults = {
+  LabelCapture: {
+    RecommendedCameraSettings: {} as any,
+    LabelCaptureBasicOverlay: {
+      DefaultPredictedFieldBrush: {} as any,
+      DefaultCapturedFieldBrush: {} as any,
+      DefaultLabelBrush: {} as any,
+    },
+    LabelCaptureValidationFlowOverlay: {
+      Settings: {
+        missingFieldsHintText: 'Missing fields',
+        standbyHintText: 'Point camera at label',
+        validationHintText: 'Validating...',
+        validationErrorText: 'Validation error',
+        requiredFieldErrorText: 'Required field',
+        manualInputButtonText: 'Enter manually',
+      },
+    },
+    Feedback: {
+      success: {} as any,
+    },
+  },
+};
+
+// Create a mock proxy with a real EventEmitter for event testing
+const createMockLabelProxy = () => {
+  const eventEmitter = new EventEmitter();
+  return {
+    subscribeForEvents: jest.fn((events: string[]) => {}),
+    unsubscribeFromEvents: jest.fn((events: string[]) => {}),
+    dispose: jest.fn(),
+    eventEmitter: eventEmitter,
+  };
+};
+
+const createMockLabelProxyAdapter = () => {
+  return {
+    registerListenerForValidationFlowEvents: jest.fn(() => Promise.resolve()),
+    unregisterListenerForValidationFlowEvents: jest.fn(() => Promise.resolve()),
+    updateLabelCaptureValidationFlowOverlay: jest.fn(() => Promise.resolve()),
+  };
+};
+
+// Mock LabelField.fromJSON
+const createMockLabelField = (name: string, text: string | null, isRequired: boolean): LabelField => {
+  return {
+    name,
+    text,
+    isRequired,
+  } as LabelField;
+};
+
+describe('LabelCaptureValidationFlowOverlayController', () => {
+  let mockOverlay: LabelCaptureValidationFlowOverlay;
+  let mockLabelCapture: LabelCapture;
+  let mockProxy: ReturnType<typeof createMockLabelProxy>;
+  let mockAdapter: ReturnType<typeof createMockLabelProxyAdapter>;
+  let controller: LabelCaptureValidationFlowOverlayController;
+  let mockListener: LabelCaptureValidationFlowListener;
+  let eventEmitterOnSpy: jest.SpiedFunction<typeof EventEmitter.prototype.on>;
+  let eventEmitterOffSpy: jest.SpiedFunction<typeof EventEmitter.prototype.off>;
+
+  beforeAll(() => {
+    FactoryMaker.bindInstanceIfNotExists('LabelCaptureDefaults', mockDefaults);
+    // Register the proxy builder - each test gets a fresh proxy
+    FactoryMaker.bindLazyInstance('LabelCaptureValidationFlowOverlayProxy', () => createMockLabelProxy());
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Create mock LabelCapture
+    const settings = LabelCaptureSettings.settingsFromLabelDefinitions([], {});
+    mockLabelCapture = new LabelCapture(settings);
+
+    // Create mock overlay
+    mockOverlay = new LabelCaptureValidationFlowOverlay(mockLabelCapture);
+
+    // Create mock adapter
+    mockAdapter = createMockLabelProxyAdapter();
+
+    // Create controller - proxy will be created by FactoryMaker
+    controller = new LabelCaptureValidationFlowOverlayController(mockOverlay);
+    // Get the proxy that was created by FactoryMaker
+    mockProxy = (controller as any)._proxy;
+    // Spy on EventEmitter methods after proxy is created
+    eventEmitterOnSpy = jest.spyOn(mockProxy.eventEmitter, 'on');
+    eventEmitterOffSpy = jest.spyOn(mockProxy.eventEmitter, 'off');
+    // Override the adapter with our mock
+    (controller as any).adapter = mockAdapter;
+
+    // Create mock listener
+    mockListener = {
+      didCaptureLabelWithFields: jest.fn(),
+      didSubmitManualInputForField: jest.fn(),
+    };
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('subscribeLabelCaptureValidationFlowListener', () => {
+    it('should register listener and subscribe to events when listener is set', async () => {
+      // given
+      mockOverlay.listener = mockListener;
+
+      // when
+      await controller.subscribeLabelCaptureValidationFlowListener();
+
+      // then
+      expect(mockProxy.subscribeForEvents).toHaveBeenCalledWith(
+        Object.values(LabelCaptureValidationFlowListenerEvents)
+      );
+      expect(eventEmitterOnSpy).toHaveBeenCalledWith(
+        LabelCaptureValidationFlowListenerEvents.didCaptureLabelWithFields,
+        expect.any(Function)
+      );
+      expect(eventEmitterOnSpy).toHaveBeenCalledWith(
+        LabelCaptureValidationFlowListenerEvents.didSubmitManualInputForField,
+        expect.any(Function)
+      );
+    });
+
+    it('should not subscribe multiple times if already subscribed', async () => {
+      // given
+      mockOverlay.listener = mockListener;
+      await controller.subscribeLabelCaptureValidationFlowListener();
+      const initialCallCount = eventEmitterOnSpy.mock.calls.length;
+
+      // when
+      await controller.subscribeLabelCaptureValidationFlowListener();
+
+      // then
+      expect(eventEmitterOnSpy.mock.calls.length).toBe(initialCallCount);
+    });
+  });
+
+  describe('unsubscribeLabelCaptureValidationFlowListener', () => {
+    it('should unregister listener and unsubscribe from events', async () => {
+      // given
+      mockOverlay.listener = mockListener;
+      await controller.subscribeLabelCaptureValidationFlowListener();
+
+      // when
+      await controller.unsubscribeLabelCaptureValidationFlowListener();
+
+      // then
+      expect(eventEmitterOffSpy).toHaveBeenCalledWith(
+        LabelCaptureValidationFlowListenerEvents.didCaptureLabelWithFields,
+        expect.any(Function)
+      );
+      expect(eventEmitterOffSpy).toHaveBeenCalledWith(
+        LabelCaptureValidationFlowListenerEvents.didSubmitManualInputForField,
+        expect.any(Function)
+      );
+      expect(mockProxy.unsubscribeFromEvents).toHaveBeenCalledWith(
+        Object.values(LabelCaptureValidationFlowListenerEvents)
+      );
+    });
+
+    it('should not unsubscribe if not subscribed', async () => {
+      // when
+      await controller.unsubscribeLabelCaptureValidationFlowListener();
+
+      // then
+      expect(eventEmitterOffSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('didSubmitManualInputForField event handling', () => {
+    it('should notify listener when didSubmitManualInputForField event is received', async () => {
+      // given
+      mockOverlay.listener = mockListener;
+      await controller.subscribeLabelCaptureValidationFlowListener();
+
+      const fieldData = {
+        name: 'Barcode',
+        text: '1234567890123',
+        isRequired: true,
+      };
+
+      const eventPayload: EventPayload = {
+        name: LabelCaptureValidationFlowListenerEvents.didSubmitManualInputForField,
+        data: JSON.stringify({
+          fields: [JSON.stringify(fieldData)],
+          oldValue: null,
+          newValue: '1234567890123',
+        }),
+      };
+
+      // Mock LabelField.fromJSON
+      const mockField = createMockLabelField(fieldData.name, fieldData.text, fieldData.isRequired);
+      jest.spyOn(LabelField as any, 'fromJSON').mockReturnValue(mockField);
+
+      // when - emit event directly on the EventEmitter
+      mockProxy.eventEmitter.emit(
+        LabelCaptureValidationFlowListenerEvents.didSubmitManualInputForField,
+        eventPayload
+      );
+
+      // then
+      expect(mockListener.didSubmitManualInputForField).toHaveBeenCalledTimes(1);
+      expect(mockListener.didSubmitManualInputForField).toHaveBeenCalledWith(mockField, null, '1234567890123');
+    });
+
+    it('should handle field with null text', async () => {
+      // given
+      mockOverlay.listener = mockListener;
+      await controller.subscribeLabelCaptureValidationFlowListener();
+
+      const fieldData = {
+        name: 'value:weight',
+        text: null,
+        isRequired: true,
+      };
+
+      const eventPayload: EventPayload = {
+        name: LabelCaptureValidationFlowListenerEvents.didSubmitManualInputForField,
+        data: JSON.stringify({
+          fields: [JSON.stringify(fieldData)],
+          oldValue: 'oldWeight',
+          newValue: 'newWeight',
+        }),
+      };
+
+      const mockField = createMockLabelField(fieldData.name, fieldData.text, fieldData.isRequired);
+      jest.spyOn(LabelField as any, 'fromJSON').mockReturnValue(mockField);
+
+      // when - emit event directly on the EventEmitter
+      mockProxy.eventEmitter.emit(
+        LabelCaptureValidationFlowListenerEvents.didSubmitManualInputForField,
+        eventPayload
+      );
+
+      // then
+      expect(mockListener.didSubmitManualInputForField).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'value:weight',
+          text: null,
+          isRequired: true,
+        }),
+        'oldWeight',
+        'newWeight'
+      );
+    });
+
+    it('should not notify listener if listener is null', async () => {
+      // given
+      mockOverlay.listener = mockListener;
+      await controller.subscribeLabelCaptureValidationFlowListener();
+      // Remove listener after subscribing
+      mockOverlay.listener = null;
+
+      const eventPayload: EventPayload = {
+        name: LabelCaptureValidationFlowListenerEvents.didSubmitManualInputForField,
+        data: JSON.stringify({
+          fields: [JSON.stringify({ name: 'Barcode', text: '123', isRequired: true })],
+          oldValue: null,
+          newValue: '123',
+        }),
+      };
+
+      // when - emit event directly on the EventEmitter
+      mockProxy.eventEmitter.emit(
+        LabelCaptureValidationFlowListenerEvents.didSubmitManualInputForField,
+        eventPayload
+      );
+
+      // then
+      expect(mockListener.didSubmitManualInputForField).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('didCaptureLabelWithFields event handling', () => {
+    it('should notify listener when didCaptureLabelWithFields event is received', async () => {
+      // given
+      mockOverlay.listener = mockListener;
+      await controller.subscribeLabelCaptureValidationFlowListener();
+
+      const fieldsData = [
+        { name: 'Barcode', text: '1234567890123', isRequired: true },
+        { name: 'value:unit_price', text: '5.99', isRequired: false },
+      ];
+
+      const eventPayload: EventPayload = {
+        name: LabelCaptureValidationFlowListenerEvents.didCaptureLabelWithFields,
+        data: JSON.stringify({
+          fields: fieldsData.map((f) => JSON.stringify(f)),
+        }),
+      };
+
+      jest.spyOn(LabelField as any, 'fromJSON').mockImplementation((json: any) => {
+        // json is already parsed by the controller before calling fromJSON
+        return createMockLabelField(json.name, json.text, json.isRequired);
+      });
+
+      // when - emit event directly on the EventEmitter
+      mockProxy.eventEmitter.emit(
+        LabelCaptureValidationFlowListenerEvents.didCaptureLabelWithFields,
+        eventPayload
+      );
+
+      // then
+      expect(mockListener.didCaptureLabelWithFields).toHaveBeenCalledTimes(1);
+      expect(mockListener.didCaptureLabelWithFields).toHaveBeenCalledWith(
+        expect.arrayContaining([
+          expect.objectContaining({ name: 'Barcode' }),
+          expect.objectContaining({ name: 'value:unit_price' }),
+        ])
+      );
+    });
+
+    it('should handle empty fields array', async () => {
+      // given
+      mockOverlay.listener = mockListener;
+      await controller.subscribeLabelCaptureValidationFlowListener();
+
+      const eventPayload: EventPayload = {
+        name: LabelCaptureValidationFlowListenerEvents.didCaptureLabelWithFields,
+        data: JSON.stringify({
+          fields: [],
+        }),
+      };
+
+      jest.spyOn(LabelField as any, 'fromJSON').mockReturnValue(null);
+
+      // when - emit event directly on the EventEmitter
+      mockProxy.eventEmitter.emit(
+        LabelCaptureValidationFlowListenerEvents.didCaptureLabelWithFields,
+        eventPayload
+      );
+
+      // then
+      expect(mockListener.didCaptureLabelWithFields).toHaveBeenCalledWith([]);
+    });
+  });
+
+  describe('updateValidationFlowOverlay', () => {
+    it('should call adapter to update overlay', async () => {
+      // given
+      const settings = LabelCaptureValidationFlowSettings.create();
+      settings.validationHintText = 'Enter value manually';
+      await mockOverlay.applySettings(settings);
+
+      // when
+      await controller.updateValidationFlowOverlay();
+
+      // then
+      expect(mockAdapter.updateLabelCaptureValidationFlowOverlay).toHaveBeenCalled();
+      const callArgs = (mockAdapter.updateLabelCaptureValidationFlowOverlay as jest.Mock).mock.calls[0][0] as { dataCaptureViewId: number; overlayJson: string };
+      expect(callArgs).toHaveProperty('dataCaptureViewId');
+      expect(callArgs).toHaveProperty('overlayJson');
+      expect(JSON.parse(callArgs.overlayJson)).toHaveProperty('hasListener');
+    });
+  });
+
+  describe('dispose', () => {
+    it('should unsubscribe and dispose proxy', async () => {
+      // given
+      mockOverlay.listener = mockListener;
+      await controller.subscribeLabelCaptureValidationFlowListener();
+
+      // when
+      controller.dispose();
+
+      // then
+      expect(mockProxy.dispose).toHaveBeenCalled();
+    });
+  });
+
+  describe('initialize', () => {
+    it('should subscribe listener if overlay has listener on construction', async () => {
+      // given
+      mockOverlay.listener = mockListener;
+      const newMockAdapter = createMockLabelProxyAdapter();
+
+      // when - create a new controller and inject our mock adapter
+      const newController = new LabelCaptureValidationFlowOverlayController(mockOverlay);
+      (newController as any).adapter = newMockAdapter;
+
+      // Wait for async initialize
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      // then - verify that subscribe was called (via eventEmitter.on)
+      const newProxy = (newController as any)._proxy;
+      // Since the controller auto-subscribes on init when listener exists,
+      // we can verify by calling subscribe again and checking it's already subscribed
+      const onSpy = jest.spyOn(newProxy.eventEmitter, 'on');
+      await newController.subscribeLabelCaptureValidationFlowListener();
+      // Should not add more listeners since already subscribed
+      expect(onSpy).not.toHaveBeenCalled();
+    });
+
+    it('should not subscribe if overlay has no listener on construction', async () => {
+      // given
+      mockOverlay.listener = null;
+      const newMockAdapter = createMockLabelProxyAdapter();
+
+      // when
+      const newController = new LabelCaptureValidationFlowOverlayController(mockOverlay);
+      (newController as any).adapter = newMockAdapter;
+      const newProxy = (newController as any)._proxy;
+      const onSpy = jest.spyOn(newProxy.eventEmitter, 'on');
+
+      // Wait for async initialize
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      // then - should not have subscribed since no listener
+      // When we subscribe now, it should actually add listeners
+      await newController.subscribeLabelCaptureValidationFlowListener();
+      expect(onSpy).toHaveBeenCalled();
+    });
+  });
+});

package/test/LabelCaptureValidationFlowSettings.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect, beforeAll } from '@jest/globals';
+import { FactoryMaker } from 'scandit-datacapture-frameworks-core';
+import { LabelCaptureValidationFlowSettings } from '../src/labelcapture/LabelCaptureValidationFlowSettings';
+import { LabelCaptureDefaults } from '../src/defaults';
+
+// Mock defaults for tests
+const mockDefaults: LabelCaptureDefaults = {
+  LabelCapture: {
+    RecommendedCameraSettings: {} as any,
+    LabelCaptureBasicOverlay: {
+      DefaultPredictedFieldBrush: {} as any,
+      DefaultCapturedFieldBrush: {} as any,
+      DefaultLabelBrush: {} as any,
+    },
+    LabelCaptureValidationFlowOverlay: {
+      Settings: {
+        missingFieldsHintText: 'Missing fields',
+        standbyHintText: 'Point camera at label',
+        validationHintText: 'Validating...',
+        validationErrorText: 'Validation error',
+        requiredFieldErrorText: 'Required field',
+        manualInputButtonText: 'Enter manually',
+      },
+    },
+    Feedback: {
+      success: {} as any,
+    },
+  },
+};
+
+describe('LabelCaptureValidationFlowSettings', () => {
+  beforeAll(() => {
+    FactoryMaker.bindInstanceIfNotExists('LabelCaptureDefaults', mockDefaults);
+  });
+
+  describe('setPlaceholderTextForLabelDefinition', () => {
+    it('should set placeholder for a field name', () => {
+      const settings = LabelCaptureValidationFlowSettings.create();
+
+      settings.setPlaceholderTextForLabelDefinition('Barcode', 'Scan barcode');
+
+      expect(settings.getPlaceholderTextForLabelDefinition('Barcode')).toBe('Scan barcode');
+    });
+
+    it('should allow setting multiple field placeholders', () => {
+      const settings = LabelCaptureValidationFlowSettings.create();
+
+      settings.setPlaceholderTextForLabelDefinition('Barcode', 'Scan barcode');
+      settings.setPlaceholderTextForLabelDefinition('value:unit_price', 'Enter price');
+      settings.setPlaceholderTextForLabelDefinition('value:weight', 'Enter weight');
+
+      expect(settings.getPlaceholderTextForLabelDefinition('Barcode')).toBe('Scan barcode');
+      expect(settings.getPlaceholderTextForLabelDefinition('value:unit_price')).toBe('Enter price');
+      expect(settings.getPlaceholderTextForLabelDefinition('value:weight')).toBe('Enter weight');
+    });
+
+    it('should remove placeholder when set to null', () => {
+      const settings = LabelCaptureValidationFlowSettings.create();
+
+      settings.setPlaceholderTextForLabelDefinition('Barcode', 'Scan barcode');
+      expect(settings.getPlaceholderTextForLabelDefinition('Barcode')).toBe('Scan barcode');
+
+      settings.setPlaceholderTextForLabelDefinition('Barcode', null);
+      expect(settings.getPlaceholderTextForLabelDefinition('Barcode')).toBeNull();
+    });
+
+    it('should override existing placeholder', () => {
+      const settings = LabelCaptureValidationFlowSettings.create();
+
+      settings.setPlaceholderTextForLabelDefinition('Barcode', 'First placeholder');
+      settings.setPlaceholderTextForLabelDefinition('Barcode', 'Second placeholder');
+
+      expect(settings.getPlaceholderTextForLabelDefinition('Barcode')).toBe('Second placeholder');
+    });
+  });
+
+  describe('getPlaceholderTextForLabelDefinition', () => {
+    it('should return null for non-existent field', () => {
+      const settings = LabelCaptureValidationFlowSettings.create();
+
+      expect(settings.getPlaceholderTextForLabelDefinition('NonExistent')).toBeNull();
+    });
+  });
+
+  describe('serialization', () => {
+    it('should not include labelDefinitionsPlaceholders when empty', () => {
+      const settings = LabelCaptureValidationFlowSettings.create();
+
+      const json = settings.toJSON() as Record<string, unknown>;
+
+      expect(json['labelDefinitionsPlaceholders']).toBeUndefined();
+    });
+
+    it('should include labelDefinitionsPlaceholders when set', () => {
+      const settings = LabelCaptureValidationFlowSettings.create();
+      settings.setPlaceholderTextForLabelDefinition('Barcode', 'Scan barcode');
+      settings.setPlaceholderTextForLabelDefinition('value:unit_price', 'Enter price');
+
+      const json = settings.toJSON() as Record<string, unknown>;
+
+      expect(json['labelDefinitionsPlaceholders']).toBeDefined();
+      const placeholders = json['labelDefinitionsPlaceholders'] as Record<string, string | null>;
+      expect(placeholders['Barcode']).toBe('Scan barcode');
+      expect(placeholders['value:unit_price']).toBe('Enter price');
+    });
+
+    it('should not include removed placeholders in serialization', () => {
+      const settings = LabelCaptureValidationFlowSettings.create();
+      settings.setPlaceholderTextForLabelDefinition('Barcode', 'Scan barcode');
+      settings.setPlaceholderTextForLabelDefinition('value:weight', 'Enter weight');
+      settings.setPlaceholderTextForLabelDefinition('Barcode', null);
+
+      const json = settings.toJSON() as Record<string, unknown>;
+
+      const placeholders = json['labelDefinitionsPlaceholders'] as Record<string, string | null>;
+      expect(placeholders['Barcode']).toBeUndefined();
+      expect(placeholders['value:weight']).toBe('Enter weight');
+    });
+  });
+});