@coveo/quantic 3.39.0 → 3.40.0

package/force-app/main/default/classes/HeadlessControllerTest.cls

@@ -1,5 +1,6 @@
 @isTest
 private class HeadlessControllerTest {
+  // This API key is intentionally public — it belongs to a sample organization used for samples/docs.
   static final String sampleHeadlessConfiguration = '{"accessToken":"xx564559b1-0045-48e1-953c-3addd1ee4457","organizationId":"searchuisamples"}';
   @IsTest
   static void shouldReturnStringifiedConfiguration() {

package/force-app/main/default/classes/InsightControllerTest.cls

@@ -1,5 +1,6 @@
 @isTest
 private class InsightControllerTest {
+  // This API key is intentionally public — it belongs to a sample organization used for samples/docs.
   static final String sampleHeadlessConfiguration = '{"accessToken":"xx564559b1-0045-48e1-953c-3addd1ee4457","organizationId":"searchuisamples"}';
   @IsTest
   static void shouldReturnStringifiedConfiguration() {

package/force-app/main/default/classes/RecommendationsControllerTest.cls

@@ -1,6 +1,6 @@
 @isTest
 private class RecommendationsControllerTest {
-  // This is a demo token and it's okay to be public.
+  // This API key is intentionally public — it belongs to a sample organization used for samples/docs.
   static final String sampleHeadlessConfiguration = '{"accessToken":"xx564559b1-0045-48e1-953c-3addd1ee4457","organizationId":"searchuisamples"}';
   @IsTest
   static void shouldReturnStringifiedConfiguration() {

package/force-app/main/default/classes/SampleTokenProvider.cls

@@ -10,6 +10,7 @@ global with sharing class SampleTokenProvider implements ITokenProvider {
     headlessConfiguration.put('organizationId', 'searchuisamples');
     headlessConfiguration.put(
       'accessToken',
+      // This API key is intentionally public — it belongs to a sample organization used for samples/docs.
       'xx564559b1-0045-48e1-953c-3addd1ee4457'
     );
     return JSON.serialize(headlessConfiguration);

package/force-app/main/default/classes/SampleTokenProviderTest.cls

@@ -1,5 +1,6 @@
 @isTest
 private class SampleTokenProviderTest {
+  // This API key is intentionally public — it belongs to a sample organization used for samples/docs.
   static final String sampleHeadlessConfiguration = '{"accessToken":"xx564559b1-0045-48e1-953c-3addd1ee4457","organizationId":"searchuisamples"}';
   @IsTest
   static void shouldReturnStringifiedConfiguration() {

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

@@ -22,6 +22,8 @@ const exampleCitations = [
     uri: 'https://example.com/2',
   },
 ];
+const exampleEngineId = 'example engine id';
+const exampleAnswerId = 'example answer id';
 jest.mock('c/quanticHeadlessLoader');
 jest.mock('c/quanticUtils', () => ({
   AriaLiveRegion: jest.fn(() => ({
@@ -50,6 +52,7 @@ jest.mock(
 
 /** @type {Object} */
 const defaultOptions = {
+  engineId: exampleEngineId,
   fieldsToIncludeInCitations: 'sfid,sfkbid,sfkavid,filetype',
   answerConfigurationId: undefined,
   withToggle: false,
@@ -348,6 +351,7 @@ describe('c-quantic-generated-answer', () => {
           isStreaming: true,
           answer: exampleAnswer,
           answerContentFormat: exampleAnswerContentFormat,
+          answerId: exampleAnswerId,
         };
         mockSuccessfulHeadlessInitialization();
         prepareHeadlessState();
@@ -461,6 +465,8 @@ describe('c-quantic-generated-answer', () => {
         expect(generatedAnswerContent.answerContentFormat).toBe(
           exampleAnswerContentFormat
         );
+        expect(generatedAnswerContent.engineId).toBe(exampleEngineId);
+        expect(generatedAnswerContent.answerId).toBe(exampleAnswerId);
       });
 
       it('should not display the generated answer actions', async () => {
@@ -784,6 +790,54 @@ describe('c-quantic-generated-answer', () => {
         expect(generatedAnswerCitations).not.toBeNull();
         expect(generatedAnswerCitations.disableCitationAnchoring).toBe(false);
       });
+
+      describe('when follow-ups are enabled', () => {
+        // TODO SFINT-6786: Add test cases to cover the behavior of the component when follow-ups are enabled based on the actual implementation of the follow-up feature in the state.
+        it.skip('should render the content section with the scrollable class and ignore the collapsible feature', async () => {
+          mockAnswerHeight = defaultAnswerHeight + 100;
+          const element = createTestComponent({
+            ...defaultOptions,
+            collapsible: true,
+          });
+          await flushPromises();
+
+          const generatedAnswerBody = element.shadowRoot.querySelector(
+            selectors.generatedAnswerBody
+          );
+
+          expect(generatedAnswerBody).not.toBeNull();
+          expect(
+            generatedAnswerBody.classList.contains(
+              'generated-answer__content--scrollable'
+            )
+          ).toBe(true);
+
+          const generatedAnswerCollapseToggle =
+            element.shadowRoot.querySelector(
+              selectors.generatedAnswerCollapseToggle
+            );
+
+          expect(generatedAnswerCollapseToggle).toBeNull();
+        });
+      });
+
+      describe('when follow-ups are not enabled', () => {
+        it('should not render the content section with the scrollable class', async () => {
+          const element = createTestComponent();
+          await flushPromises();
+
+          const generatedAnswerBody = element.shadowRoot.querySelector(
+            selectors.generatedAnswerBody
+          );
+
+          expect(generatedAnswerBody).not.toBeNull();
+          expect(
+            generatedAnswerBody.classList.contains(
+              'generated-answer__content--scrollable'
+            )
+          ).toBe(false);
+        });
+      });
     });
 
     describe('when the answer cannot be generated after a query is executed', () => {

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

@@ -172,6 +172,8 @@ export default class QuanticGeneratedAnswer extends LightningElement {
   /** @type {boolean} */
   hasInitializationError = false;
   /** @type {boolean} */
+  _areFollowUpsEnabled = false;
+  /** @type {boolean} */
   _exceedsMaximumHeight = false;
   /** @type {boolean} */
   _liked = false;
@@ -196,7 +198,7 @@ export default class QuanticGeneratedAnswer extends LightningElement {
 
   renderedCallback() {
     initializeWithHeadless(this, this.engineId, this.initialize);
-    if (this.collapsible) {
+    if (this.isCollapsibleEnabled) {
       this._exceedsMaximumHeight = this.isMaximumHeightExceeded();
     }
   }
@@ -259,7 +261,7 @@ export default class QuanticGeneratedAnswer extends LightningElement {
     this.updateFeedbackState();
     this.ariaLiveMessage.dispatchMessage(this.getGeneratedAnswerStatus());
 
-    if (this.collapsible) {
+    if (this.isCollapsibleEnabled) {
       this.updateGeneratedAnswerCSSVariables();
     }
   }
@@ -400,7 +402,7 @@ export default class QuanticGeneratedAnswer extends LightningElement {
 
   handleAnswerContentUpdated = (event) => {
     event.stopPropagation();
-    if (this.collapsible) {
+    if (this.isCollapsibleEnabled) {
       this._exceedsMaximumHeight = this.isMaximumHeightExceeded();
     }
     this.updateGeneratedAnswerCSSVariables();
@@ -456,6 +458,10 @@ export default class QuanticGeneratedAnswer extends LightningElement {
     return this?.state?.answer;
   }
 
+  get answerId() {
+    return this?.state?.answerId;
+  }
+
   get citations() {
     return this?.state?.citations;
   }
@@ -481,6 +487,15 @@ export default class QuanticGeneratedAnswer extends LightningElement {
     return this.state.isVisible;
   }
 
+  get areFollowUpsEnabled() {
+    // TODO SFINT-6786: Modify this getter to return the actual value from the state for follow-up enabled/agentId.
+    return this._areFollowUpsEnabled;
+  }
+
+  get isCollapsibleEnabled() {
+    return this.collapsible && !this.areFollowUpsEnabled;
+  }
+
   get isAnswerCollapsed() {
     // Answer is considered collapsed only if it exceeds the maximum height and was not expanded.
     return this._exceedsMaximumHeight && !this.isExpanded;
@@ -501,6 +516,14 @@ export default class QuanticGeneratedAnswer extends LightningElement {
     return `generated-answer__answer ${collapsedStateClass}`;
   }
 
+  get contentSectionClass() {
+    const baseClass =
+      'generated-answer__content slds-p-top_medium slds-p-horizontal_large';
+    return this.areFollowUpsEnabled
+      ? `${baseClass} generated-answer__content--scrollable`
+      : baseClass;
+  }
+
   get hasRetryableError() {
     return !this?.searchStatusState?.hasError && this.state?.error?.isRetryable;
   }

package/force-app/main/default/lwc/quanticGeneratedAnswer/templates/generatedAnswer.css

@@ -9,6 +9,11 @@
   word-wrap: break-word;
 }
 
+.generated-answer__content--scrollable {
+  overflow-y: auto;
+  height: var(--quantic-generated-answer-content-fixed-height, 50vh);
+}
+
 .generated-answer__footer {
   gap: 1rem;
 }

package/force-app/main/default/lwc/quanticGeneratedAnswer/templates/generatedAnswer.html

@@ -27,13 +27,15 @@
       <template lwc:if={isVisible}>
         <section
           data-testid="generated-answer__body"
-          class="generated-answer__content slds-p-top_medium slds-p-horizontal_large"
+          class={contentSectionClass}
         >
           <div
             data-testid="generated-answer__answer"
             class={generatedAnswerClass}
           >
             <c-quantic-generated-answer-content
+              engine-id={engineId}
+              answer-id={answerId}
               answer-content-format={answerContentFormat}
               answer={answer}
               is-streaming={isStreaming}

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

@@ -1,8 +1,11 @@
+/* eslint-disable no-import-assign */
 // @ts-ignore
 import QuanticGeneratedAnswerContent from 'c/quanticGeneratedAnswerContent';
 import {createElement} from 'lwc';
 import {loadMarkdownDependencies} from 'c/quanticUtils';
+import * as mockHeadlessLoader from 'c/quanticHeadlessLoader';
 
+jest.mock('c/quanticHeadlessLoader');
 jest.mock('c/quanticUtils', () => ({
   loadMarkdownDependencies: jest.fn(
     () =>
@@ -11,6 +14,9 @@ jest.mock('c/quanticUtils', () => ({
       })
   ),
   transformMarkdownToHtml: jest.fn((value) => value),
+  LinkUtils: {
+    bindAnalyticsToLink: jest.fn(() => jest.fn()),
+  },
 }));
 
 const mockMarkedUse = jest.fn();
@@ -23,14 +29,47 @@ global.marked = {
 const SELECTORS = {
   textAnswerContainer: 'span.generated-answer-content__answer',
   markdownAnswerContainer: 'div.generated-answer-content__answer',
+  inlineLink: 'a[data-answer-inline-link]',
+  inlineLinkIconContainer: 'span.slds-icon_container',
+  inlineLinkIconSvg: 'svg.slds-icon',
 };
 
+const exampleEngineId = 'example-engine-id';
+const exampleAnswerId = 'example-answer-id';
+
 const defaultOptions = {
   isStreaming: false,
   answerContentFormat: 'text/plain',
   answer: '',
 };
 
+const exampleEngine = {id: 'dummy-engine'};
+let isInitialized = false;
+
+const mockBuildInteractiveGeneratedAnswerInlineLink = jest.fn(() => ({
+  select: jest.fn(),
+  beginDelayedSelect: jest.fn(),
+  cancelPendingSelect: jest.fn(),
+}));
+
+function prepareHeadlessState() {
+  // @ts-ignore
+  mockHeadlessLoader.getHeadlessBundle = () => ({
+    buildInteractiveGeneratedAnswerInlineLink:
+      mockBuildInteractiveGeneratedAnswerInlineLink,
+  });
+}
+
+function mockSuccessfulHeadlessInitialization() {
+  // @ts-ignore
+  mockHeadlessLoader.initializeWithHeadless = (element, _, initialize) => {
+    if (element instanceof QuanticGeneratedAnswerContent && !isInitialized) {
+      isInitialized = true;
+      initialize(exampleEngine);
+    }
+  };
+}
+
 function createTestComponent(options = defaultOptions) {
   const element = createElement('c-quantic-generated-answer-content', {
     is: QuanticGeneratedAnswerContent,
@@ -43,6 +82,20 @@ function createTestComponent(options = defaultOptions) {
   return element;
 }
 
+/**
+ * Builds an HTML string containing anchor tags with the data-answer-inline-link
+ * attribute, which is what the component's processInlineLinks method targets.
+ * @param {Array<{href: string, text: string}>} links
+ * @returns {string}
+ */
+function buildAnswerWithInlineLinks(links) {
+  return links
+    .map(
+      ({href, text}) => `<a href="${href}" data-answer-inline-link>${text}</a>`
+    )
+    .join(' ');
+}
+
 // Helper function to wait until the microtask queue is empty.
 function flushPromises() {
   // eslint-disable-next-line @lwc/lwc/no-async-operation
@@ -56,6 +109,7 @@ describe('c-quantic-generated-answer-content', () => {
       document.body.removeChild(document.body.firstChild);
     }
     jest.clearAllMocks();
+    isInitialized = false;
   }
 
   afterEach(() => {
@@ -148,4 +202,219 @@ describe('c-quantic-generated-answer-content', () => {
       expect(loadMarkdownDependencies).toHaveBeenCalled();
     });
   });
+
+  describe('inline links in a markdown answer', () => {
+    const exampleLinks = [
+      {href: 'https://example.com/1', text: 'Link one'},
+      {href: 'https://example.com/2', text: 'Link two'},
+    ];
+
+    beforeEach(() => {
+      mockSuccessfulHeadlessInitialization();
+      prepareHeadlessState();
+    });
+
+    describe('when the answer contains anchors with data-answer-inline-link', () => {
+      it('should set target="_blank" and append an icon span to each inline link anchor', async () => {
+        const {LinkUtils} = jest.requireMock('c/quanticUtils');
+        LinkUtils.bindAnalyticsToLink.mockReturnValue(jest.fn());
+
+        const element = createTestComponent({
+          ...defaultOptions,
+          engineId: exampleEngineId,
+          answerId: exampleAnswerId,
+          answerContentFormat: 'text/markdown',
+          answer: buildAnswerWithInlineLinks(exampleLinks),
+        });
+        await flushPromises();
+
+        const answerContainer = element.shadowRoot.querySelector(
+          SELECTORS.markdownAnswerContainer
+        );
+        const anchors = answerContainer.querySelectorAll(SELECTORS.inlineLink);
+
+        expect(anchors).toHaveLength(exampleLinks.length);
+        anchors.forEach((anchor) => {
+          expect(anchor.target).toBe('_blank');
+        });
+        anchors.forEach((anchor) => {
+          const iconSpan = anchor.querySelector(
+            SELECTORS.inlineLinkIconContainer
+          );
+          expect(iconSpan).not.toBeNull();
+          expect(iconSpan.classList).toContain('slds-icon-utility-new_window');
+          expect(iconSpan.classList).toContain('slds-current-color');
+          expect(
+            iconSpan.querySelector(SELECTORS.inlineLinkIconSvg)
+          ).not.toBeNull();
+        });
+      });
+
+      it('should call buildInteractiveGeneratedAnswerInlineLink with the correct parameters for each inline link', async () => {
+        const {LinkUtils} = jest.requireMock('c/quanticUtils');
+        LinkUtils.bindAnalyticsToLink.mockReturnValue(jest.fn());
+
+        createTestComponent({
+          ...defaultOptions,
+          engineId: exampleEngineId,
+          answerId: exampleAnswerId,
+          answerContentFormat: 'text/markdown',
+          answer: buildAnswerWithInlineLinks(exampleLinks),
+        });
+        await flushPromises();
+
+        expect(
+          mockBuildInteractiveGeneratedAnswerInlineLink
+        ).toHaveBeenCalledTimes(exampleLinks.length);
+        expect(LinkUtils.bindAnalyticsToLink).toHaveBeenCalledTimes(
+          exampleLinks.length
+        );
+
+        exampleLinks.forEach((anchor, index) => {
+          expect(
+            mockBuildInteractiveGeneratedAnswerInlineLink
+          ).toHaveBeenNthCalledWith(index + 1, exampleEngine, {
+            options: {
+              link: {
+                linkURL: anchor.href,
+                linkText: anchor.text,
+              },
+              answerId: exampleAnswerId,
+            },
+          });
+        });
+      });
+
+      it('should call LinkUtils.bindAnalyticsToLink for each inline link with the anchor and its controller', async () => {
+        const {LinkUtils} = jest.requireMock('c/quanticUtils');
+        const mockUnbind = jest.fn();
+        LinkUtils.bindAnalyticsToLink.mockReturnValue(mockUnbind);
+
+        const element = createTestComponent({
+          ...defaultOptions,
+          engineId: exampleEngineId,
+          answerId: exampleAnswerId,
+          answerContentFormat: 'text/markdown',
+          answer: buildAnswerWithInlineLinks(exampleLinks),
+        });
+        await flushPromises();
+
+        expect(LinkUtils.bindAnalyticsToLink).toHaveBeenCalledTimes(
+          exampleLinks.length
+        );
+
+        const answerContainer = element.shadowRoot.querySelector(
+          SELECTORS.markdownAnswerContainer
+        );
+        const anchors = Array.from(
+          answerContainer.querySelectorAll(SELECTORS.inlineLink)
+        );
+
+        anchors.forEach((anchor, index) => {
+          expect(LinkUtils.bindAnalyticsToLink).toHaveBeenNthCalledWith(
+            index + 1,
+            anchor,
+            expect.objectContaining({
+              select: expect.any(Function),
+              beginDelayedSelect: expect.any(Function),
+              cancelPendingSelect: expect.any(Function),
+            })
+          );
+        });
+      });
+    });
+
+    describe('when the answer does not contain anchors with data-answer-inline-link', () => {
+      it('should not call buildInteractiveGeneratedAnswerInlineLink and LinkUtils.bindAnalyticsToLink', async () => {
+        const {LinkUtils} = jest.requireMock('c/quanticUtils');
+
+        createTestComponent({
+          ...defaultOptions,
+          engineId: exampleEngineId,
+          answerId: exampleAnswerId,
+          answerContentFormat: 'text/markdown',
+          answer: '<p>No inline links here</p>',
+        });
+        await flushPromises();
+
+        expect(
+          mockBuildInteractiveGeneratedAnswerInlineLink
+        ).not.toHaveBeenCalled();
+        expect(LinkUtils.bindAnalyticsToLink).not.toHaveBeenCalled();
+      });
+    });
+
+    describe('when the headless bundle does not expose buildInteractiveGeneratedAnswerInlineLink', () => {
+      it('should not throw and should not call LinkUtils.bindAnalyticsToLink', async () => {
+        // @ts-ignore
+        mockHeadlessLoader.getHeadlessBundle = () => ({});
+        const {LinkUtils} = jest.requireMock('c/quanticUtils');
+
+        expect(() => {
+          createTestComponent({
+            ...defaultOptions,
+            engineId: exampleEngineId,
+            answerId: exampleAnswerId,
+            answerContentFormat: 'text/markdown',
+            answer: buildAnswerWithInlineLinks(exampleLinks),
+          });
+        }).not.toThrow();
+
+        await flushPromises();
+
+        expect(LinkUtils.bindAnalyticsToLink).not.toHaveBeenCalled();
+      });
+    });
+
+    describe('when the answer is updated', () => {
+      it('should clean up previous inline link bindings before processing the new answer', async () => {
+        const {LinkUtils} = jest.requireMock('c/quanticUtils');
+        const mockUnbind = jest.fn();
+        LinkUtils.bindAnalyticsToLink.mockReturnValue(mockUnbind);
+
+        const element = createTestComponent({
+          ...defaultOptions,
+          engineId: exampleEngineId,
+          answerId: exampleAnswerId,
+          answerContentFormat: 'text/markdown',
+          answer: buildAnswerWithInlineLinks(exampleLinks),
+        });
+        await flushPromises();
+
+        expect(mockUnbind).not.toHaveBeenCalled();
+
+        const updatedLinks = [
+          {href: 'https://example.com/3', text: 'Link three'},
+        ];
+        element.answer = buildAnswerWithInlineLinks(updatedLinks);
+        await flushPromises();
+
+        expect(mockUnbind).toHaveBeenCalledTimes(exampleLinks.length);
+      });
+    });
+
+    describe('when the component is disconnected', () => {
+      it('should call the unbind function for each inline link binding', async () => {
+        const {LinkUtils} = jest.requireMock('c/quanticUtils');
+        const mockUnbind = jest.fn();
+        LinkUtils.bindAnalyticsToLink.mockReturnValue(mockUnbind);
+
+        const element = createTestComponent({
+          ...defaultOptions,
+          engineId: exampleEngineId,
+          answerId: exampleAnswerId,
+          answerContentFormat: 'text/markdown',
+          answer: buildAnswerWithInlineLinks(exampleLinks),
+        });
+        await flushPromises();
+
+        expect(mockUnbind).not.toHaveBeenCalled();
+
+        document.body.removeChild(element);
+        await flushPromises();
+
+        expect(mockUnbind).toHaveBeenCalledTimes(exampleLinks.length);
+      });
+    });
+  });
 });