Form Smart Paste: call onFieldDataChanged on item value update (#30953)

Author: anna-shakhova

packages/devextreme/js/__internal/ui/form/form.ts

@@ -1855,15 +1855,20 @@ class Form extends Widget<FormProperties> {
     this._abort?.();
     this._abort = undefined;
     this._currentAICommand = undefined;
-    this._hideLoadPanel();
   }
 
   private _processAIIntegrationUpdate(): void {
     if (this._currentAICommand) {
       const { command, params, callbacks } = this._currentAICommand;
+      const { aiIntegration } = this.option();
 
       this._processCommandCompletion();
-      this._executeAICommand(command, params, callbacks);
+
+      if (!aiIntegration) {
+        this._hideLoadPanel();
+      } else {
+        this._executeAICommand(command, params, callbacks);
+      }
     }
   }
 
@@ -1896,6 +1901,7 @@ class Form extends Widget<FormProperties> {
         invokeConditionally(
           smartPastingArgs.cancel,
           (): void => {
+            this._hideLoadPanel();
             this.beginUpdate();
             fieldsData.forEach(({ name, value }: SmartPasteCommandResult[number]) => {
               this._updateFieldValue(name, value);

packages/devextreme/testing/tests/DevExpress.ui.widgets.form/form.aiIntegration.tests.js

@@ -464,7 +464,7 @@ QUnit.module('SmartPaste', () => {
             });
         });
 
-        QUnit.test('LoadPanel is hidden when smartPaste operation is aborted', function(assert) {
+        QUnit.test('LoadPanel not hidden on aiIntegration update during command execution', function(assert) {
             const done = assert.async();
             let abortCallback;
 
@@ -485,6 +485,38 @@ QUnit.module('SmartPaste', () => {
 
                     form.option('aiIntegration', { smartPaste: sinon.stub().callsFake(() => () => {}) });
 
+                    setTimeout(() => {
+                        assert.strictEqual(abortCallback.calledOnce, true, 'Previous operation was aborted');
+                        assert.strictEqual(form._loadPanel.option('visible'), true, 'LoadPanel is hidden after abort');
+                        assert.strictEqual(form.option('disabled'), true, 'Form is not disabled after abort');
+
+                        done();
+                    }, 10);
+                }, 10);
+            });
+        });
+
+        QUnit.test('LoadPanel is hidden on aiIntegration remove during command execution', function(assert) {
+            const done = assert.async();
+            let abortCallback;
+
+            const smartPaste = sinon.stub().callsFake((params, callbacks) => {
+                abortCallback = sinon.spy();
+                return abortCallback;
+            });
+            const aiIntegration = { smartPaste: smartPaste };
+            const form = setupFormWithAi({ aiIntegration });
+
+            this.clipboardStub = this.createClipboardStub('test text');
+
+            form.smartPaste().then(() => {
+                setTimeout(() => {
+                    assert.strictEqual(form.$element().find(`.${FORM_LOAD_PANEL_CLASS}`).length, 1, 'LoadPanel is shown during operation');
+                    assert.strictEqual(form.option('disabled'), true, 'Form is disabled during operation');
+                    assert.ok(abortCallback, 'Abort callback was created');
+
+                    form.option('aiIntegration', undefined);
+
                     setTimeout(() => {
                         assert.strictEqual(abortCallback.calledOnce, true, 'Previous operation was aborted');
                         assert.strictEqual(form.$element().find(`.${FORM_LOAD_PANEL_CLASS}`).length, 1, 'LoadPanel is still present but hidden');
@@ -765,6 +797,30 @@ QUnit.module('SmartPaste', () => {
                 assert.strictEqual(onSmartPasted.calledOnce, true, 'onSmartPasted event has been invoked after its change at runtime');
             });
         });
+
+        QUnit.test('should invoke onDataFieldChanged for each updated field after smartPaste', function(assert) {
+            const aiResult = [
+                { name: 'field1', value: 'value1' },
+                { name: 'field2', value: 'value2' },
+            ];
+            const smartPaste = (_, callbacks) => {
+                callbacks.onComplete(aiResult);
+            };
+            const onFieldDataChanged = sinon.spy();
+
+            const form = setupFormWithAi({
+                aiIntegration: { smartPaste },
+                onFieldDataChanged
+            });
+
+            form.smartPaste('text');
+
+            const onFieldDataChangedCalls = onFieldDataChanged.getCalls();
+
+            assert.strictEqual(onFieldDataChangedCalls.length, 2, 'onFieldDataChanged called twice');
+            assert.propContains(onFieldDataChangedCalls[0].args[0], { dataField: 'field1', value: 'value1' }, 'onFieldDataChanged called for 1st field with correct args');
+            assert.propContains(onFieldDataChangedCalls[1].args[0], { dataField: 'field2', value: 'value2' }, 'onFieldDataChanged called for 2nd field with correct args');
+        });
     });
 
     QUnit.module('aiOptions', {