@coveo/quantic 3.9.1-pre.bbf2cab18e → 3.10.0-pre.c5a50cf39c

package/force-app/main/default/lwc/jsconfig.json

@@ -86,6 +86,9 @@
       "c/quanticGeneratedAnswerContent": [
         "quanticGeneratedAnswerContent/quanticGeneratedAnswerContent.js"
       ],
+      "c/quanticGeneratedAnswer": [
+        "quanticGeneratedAnswer/quanticGeneratedAnswer.js"
+      ],
       "c/*": ["*"]
     }
   },

package/force-app/main/default/lwc/quanticGeneratedAnswer/__tests__/quanticGeneratedAnswer.test.js

@@ -0,0 +1,115 @@
+/* eslint-disable no-import-assign */
+// @ts-ignore
+import {createElement} from 'lwc';
+import QuanticGeneratedAnswer from 'c/quanticGeneratedAnswer';
+import * as mockHeadlessLoader from 'c/quanticHeadlessLoader';
+
+jest.mock('c/quanticHeadlessLoader');
+
+function createTestComponent(options = {}) {
+  prepareHeadlessState();
+
+  const element = createElement('c-quantic-generated-answer', {
+    is: QuanticGeneratedAnswer,
+  });
+  for (const [key, value] of Object.entries(options)) {
+    element[key] = value;
+  }
+
+  document.body.appendChild(element);
+  return element;
+}
+
+const functionsMocks = {
+  buildGeneratedAnswer: jest.fn(() => ({
+    subscribe: jest.fn((callback) => callback()),
+    state: {},
+  })),
+  buildSearchStatus: jest.fn(() => ({
+    subscribe: jest.fn((callback) => callback()),
+    state: {},
+  })),
+};
+
+function prepareHeadlessState() {
+  // @ts-ignore
+  mockHeadlessLoader.getHeadlessBundle = () => {
+    return {
+      buildGeneratedAnswer: functionsMocks.buildGeneratedAnswer,
+      buildSearchStatus: functionsMocks.buildSearchStatus,
+    };
+  };
+}
+
+// Helper function to wait until the microtask queue is empty.
+function flushPromises() {
+  // eslint-disable-next-line @lwc/lwc/no-async-operation
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+const exampleEngine = {
+  id: 'dummy engine',
+};
+let isInitialized = false;
+
+function mockSuccessfulHeadlessInitialization() {
+  // @ts-ignore
+  mockHeadlessLoader.initializeWithHeadless = (element, _, initialize) => {
+    if (element instanceof QuanticGeneratedAnswer && !isInitialized) {
+      isInitialized = true;
+      initialize(exampleEngine);
+    }
+  };
+}
+
+function cleanup() {
+  // The jsdom instance is shared across test cases in a single file so reset the DOM
+  while (document.body.firstChild) {
+    document.body.removeChild(document.body.firstChild);
+  }
+  jest.clearAllMocks();
+  isInitialized = false;
+}
+
+describe('c-quantic-generated-answer', () => {
+  beforeAll(() => {
+    mockSuccessfulHeadlessInitialization();
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+
+  describe('controller initialization', () => {
+    describe('when the answer configuration id property is passed to the component', () => {
+      it('should initialize the controller with the correct answer configuration id value', async () => {
+        const exampleAnswerConfigValue = 'exampleAnswerConfig';
+        createTestComponent({answerConfigurationId: exampleAnswerConfigValue});
+        await flushPromises();
+
+        expect(functionsMocks.buildGeneratedAnswer).toHaveBeenCalledTimes(1);
+        expect(functionsMocks.buildGeneratedAnswer).toHaveBeenCalledWith(
+          exampleEngine,
+          expect.objectContaining({
+            answerConfigurationId: exampleAnswerConfigValue,
+          })
+        );
+      });
+    });
+
+    describe('when the answer configuration id property is not passed to the component', () => {
+      it('should initialize the controller without the answer configuration id value', async () => {
+        createTestComponent();
+        await flushPromises();
+
+        expect(functionsMocks.buildGeneratedAnswer).toHaveBeenCalledTimes(1);
+        expect(functionsMocks.buildGeneratedAnswer).toHaveBeenCalledWith(
+          exampleEngine,
+          expect.not.objectContaining({
+            answerConfigurationId: expect.any(String),
+          })
+        );
+      });
+    });
+  });
+});

package/force-app/main/default/lwc/quanticGeneratedAnswer/quanticGeneratedAnswer.js

@@ -80,6 +80,12 @@ export default class QuanticGeneratedAnswer extends LightningElement {
    * @default {false}
    */
   @api withToggle = false;
+  /**
+   * @internal
+   * The unique identifier of the answer configuration to use to generate the answer.
+   * @type {string}
+   */
+  @api answerConfigurationId;
 
   labels = {
     generatedAnswerForYou,
@@ -187,6 +193,9 @@ export default class QuanticGeneratedAnswer extends LightningElement {
           contentFormat: ['text/markdown', 'text/plain'],
         },
       },
+      ...(this.answerConfigurationId && {
+        answerConfigurationId: this.answerConfigurationId,
+      }),
       fieldsToIncludeInCitations: this.citationFields,
     });
   }
@@ -421,12 +430,7 @@ export default class QuanticGeneratedAnswer extends LightningElement {
 
   get shouldDisplayGeneratedAnswer() {
     const hasCitations = !!this.citations?.length;
-    return (
-      !!this.answer ||
-      this.isStreaming ||
-      hasCitations ||
-      this.hasRetryableError
-    );
+    return !!this.answer || hasCitations || this.hasRetryableError;
   }
 
   get generatedAnswerClass() {

package/force-app/main/default/lwc/quanticGeneratedAnswerContent/__tests__/quanticGeneratedAnswerContent.test.js

@@ -1,6 +1,17 @@
 // @ts-ignore
 import QuanticGeneratedAnswerContent from 'c/quanticGeneratedAnswerContent';
 import {createElement} from 'lwc';
+import {loadMarkdownDependencies} from 'c/quanticUtils';
+
+jest.mock('c/quanticUtils', () => ({
+  loadMarkdownDependencies: jest.fn(
+    () =>
+      new Promise((resolve) => {
+        resolve();
+      })
+  ),
+  transformMarkdownToHtml: jest.fn((value) => value),
+}));
 
 const mockMarkedUse = jest.fn();
 const mockMarkedParse = jest.fn((text) => text);
@@ -122,4 +133,19 @@ describe('c-quantic-generated-answer-content', () => {
       );
     });
   });
+
+  describe('the reactivity of the answerContentFormat property', () => {
+    it('should load the markdown dependencies when the answerContentFormat property is changed to text/markdown', async () => {
+      const element = createTestComponent({
+        ...defaultOptions,
+        answerContentFormat: 'text/plain',
+      });
+      await flushPromises();
+      expect(loadMarkdownDependencies).not.toHaveBeenCalled();
+
+      element.answerContentFormat = 'text/markdown';
+      await flushPromises();
+      expect(loadMarkdownDependencies).toHaveBeenCalled();
+    });
+  });
 });

package/force-app/main/default/lwc/quanticGeneratedAnswerContent/quanticGeneratedAnswerContent.js

@@ -28,7 +28,19 @@ export default class QuanticGeneratedAnswerContent extends LightningElement {
    * @type {'text/plain' | 'text/markdown'}
    * @default {'text/plain'}
    */
-  @api answerContentFormat = 'text/plain';
+  @api
+  get answerContentFormat() {
+    return this._answerContentFormat;
+  }
+  set answerContentFormat(value) {
+    this._answerContentFormat = value;
+    if (
+      this._answerContentFormat === 'text/markdown' &&
+      !this._markdownDependenciesLoaded
+    ) {
+      this.loadMarkdownDependencies();
+    }
+  }
   /**
    * The answer content to display.
    * @api
@@ -42,30 +54,29 @@ export default class QuanticGeneratedAnswerContent extends LightningElement {
     this._answer = value;
     if (
       this.answerContentFormat === 'text/markdown' &&
-      this._markedLoaded &&
-      this._domPurifyLoaded
+      this._markdownDependenciesLoaded
     ) {
       this.updateHtmlContent();
     }
   }
 
   _answer;
-  _markedLoaded = false;
-  _domPurifyLoaded = false;
+  /** @type {'text/plain' | 'text/markdown'} */
+  _answerContentFormat = 'text/plain';
+  _markdownDependenciesLoaded = false;
 
-  connectedCallback() {
-    if (this.answerContentFormat === 'text/markdown') {
+  loadMarkdownDependencies() {
+    if (
+      !this._markdownDependenciesLoaded &&
+      this.answerContentFormat === 'text/markdown'
+    ) {
       loadMarkdownDependencies(this)
         .then(() => {
-          // @ts-ignore
-          this._markedLoaded = true;
-          // @ts-ignore
-          this._domPurifyLoaded = true;
+          this._markdownDependenciesLoaded = true;
           this.updateHtmlContent();
         })
         .catch((error) => {
           console.error('Error loading the Marked library.', error);
-          this._markedLoadingError = true;
         });
     }
   }
@@ -74,11 +85,12 @@ export default class QuanticGeneratedAnswerContent extends LightningElement {
     const answerContainer = this.template.querySelector(
       '.generated-answer-content__answer'
     );
-    if (this._markedLoaded && this._domPurifyLoaded) {
+    if (this._markdownDependenciesLoaded) {
       // Transform the markdown answer to HTML and update the innerHTML of the container
       const newHTMLContent =
         // @ts-ignore
         (window.marked &&
+          this.answer &&
           // @ts-ignore
           transformMarkdownToHtml(this.answer, window.marked)) ||
         '';