@coveo/quantic 3.10.0-pre.c5a50cf39c → 3.10.0-pre.d66d49ebbe

package/docs/out/quantic-docs.json

@@ -382,7 +382,7 @@
                 ],
                 "fires": "",
                 "examples": [
-                    "<c-quantic-did-you-mean engine-id={engineId}></c-quantic-did-you-mean>"
+                    "<c-quantic-did-you-mean engine-id={engineId} disable-query-auto-correction={disableQueryAutoCorrection} query-correction-mode=\"next\"></c-quantic-did-you-mean>"
                 ],
                 "xmlMeta": {
                     "apiVersion": "53.0",
@@ -398,6 +398,24 @@
                         "required": true,
                         "defaultValue": "",
                         "type": "string"
+                    },
+                    {
+                        "name": "disableQueryAutoCorrection",
+                        "attribute": "disable-query-auto-correction",
+                        "access": "@api",
+                        "description": "<p>Whether to disable automatically applying corrections for queries that would otherwise return no results.\nWhen <code>disableQueryAutoCorrection</code> is <code>false</code>, the component automatically triggers a new query using the suggested term.\nWhen <code>disableQueryAutoCorrection</code> is <code>true</code>, the component returns the suggested term without triggering a new query.</p>",
+                        "required": false,
+                        "defaultValue": "false",
+                        "type": "boolean"
+                    },
+                    {
+                        "name": "queryCorrectionMode",
+                        "attribute": "query-correction-mode",
+                        "access": "@api",
+                        "description": "<p>Defines which query correction system to use.\n<code>legacy</code>: Query correction is powered by the legacy index system. This system relies on an algorithm using solely the index content to compute the suggested terms.\n<code>next</code>: Query correction is powered by a machine learning system, requiring a valid query suggestion model configured in your Coveo environment to function properly. This system relies on machine learning algorithms to compute the suggested terms.\nThe <code>legacy</code> system will send two requests to the API to get the suggestions, while the <code>next</code> system will send one request.</p>",
+                        "required": false,
+                        "defaultValue": "'legacy'",
+                        "type": "string"
                     }
                 ]
             },
@@ -4315,7 +4333,7 @@
                 ],
                 "fires": "",
                 "examples": [
-                    "<c-quantic-did-you-mean engine-id={engineId}></c-quantic-did-you-mean>"
+                    "<c-quantic-did-you-mean engine-id={engineId} disable-query-auto-correction={disableQueryAutoCorrection} query-correction-mode=\"next\"></c-quantic-did-you-mean>"
                 ],
                 "xmlMeta": {
                     "apiVersion": "53.0",
@@ -4331,6 +4349,24 @@
                         "required": true,
                         "defaultValue": "",
                         "type": "string"
+                    },
+                    {
+                        "name": "disableQueryAutoCorrection",
+                        "attribute": "disable-query-auto-correction",
+                        "access": "@api",
+                        "description": "<p>Whether to disable automatically applying corrections for queries that would otherwise return no results.\nWhen <code>disableQueryAutoCorrection</code> is <code>false</code>, the component automatically triggers a new query using the suggested term.\nWhen <code>disableQueryAutoCorrection</code> is <code>true</code>, the component returns the suggested term without triggering a new query.</p>",
+                        "required": false,
+                        "defaultValue": "false",
+                        "type": "boolean"
+                    },
+                    {
+                        "name": "queryCorrectionMode",
+                        "attribute": "query-correction-mode",
+                        "access": "@api",
+                        "description": "<p>Defines which query correction system to use.\n<code>legacy</code>: Query correction is powered by the legacy index system. This system relies on an algorithm using solely the index content to compute the suggested terms.\n<code>next</code>: Query correction is powered by a machine learning system, requiring a valid query suggestion model configured in your Coveo environment to function properly. This system relies on machine learning algorithms to compute the suggested terms.\nThe <code>legacy</code> system will send two requests to the API to get the suggestions, while the <code>next</code> system will send one request.</p>",
+                        "required": false,
+                        "defaultValue": "'legacy'",
+                        "type": "string"
                     }
                 ]
             },

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

@@ -64,6 +64,14 @@ export default class QuanticCaseAssistInterface extends LightningElement {
                       ...(document.referrer && {
                         originLevel3: document.referrer.substring(0, 256),
                       }),
+                      analyticsClientMiddleware: (_event, payload) => {
+                        if (!payload.customData) {
+                          payload.customData = {};
+                        }
+                        payload.customData.coveoQuanticVersion =
+                          window.coveoQuanticVersion;
+                        return payload;
+                      },
                     },
                     ...rest,
                   },

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

@@ -15,16 +15,21 @@ jest.mock('c/quanticUtils', () => ({
       CATEGORYFACETS: 'categoryFacets',
     },
   },
+  I18nUtils: {
+    format: jest.fn(),
+  },
 }));
 jest.mock('c/quanticHeadlessLoader');
 
 const selectors = {
   facetContent: '[data-test="facet-content"]',
+  componentError: 'c-quantic-component-error',
 };
 
 const exampleFacetId = 'example facet id';
+const exampleField = 'exampleField';
 const defaultOptions = {
-  field: 'example field',
+  field: exampleField,
 };
 const categoryFacetControllerMock = {
   subscribe: jest.fn((callback) => callback()),
@@ -33,6 +38,8 @@ const categoryFacetControllerMock = {
     values: [],
   },
 };
+const parentFacetIdError = `The ${exampleField} c-quantic-category-facet requires dependsOn.parentFacetId to be a valid string.`;
+const expectedValueError = `The ${exampleField} c-quantic-category-facet requires dependsOn.expectedValue to be a valid string.`;
 
 function createTestComponent(options = defaultOptions) {
   prepareHeadlessState();
@@ -82,6 +89,21 @@ const exampleEngine = {
 };
 let isInitialized = false;
 
+function mockBueno() {
+  // @ts-ignore
+  mockHeadlessLoader.getBueno = () => {
+    // @ts-ignore
+    global.Bueno = {
+      isString: jest
+        .fn()
+        .mockImplementation(
+          (value) => Object.prototype.toString.call(value) === '[object String]'
+        ),
+    };
+    return new Promise((resolve) => resolve());
+  };
+}
+
 function mockSuccessfulHeadlessInitialization() {
   // @ts-ignore
   mockHeadlessLoader.initializeWithHeadless = (element, _, initialize) => {
@@ -104,6 +126,7 @@ function cleanup() {
 describe('c-quantic-category-facet', () => {
   beforeAll(() => {
     mockSuccessfulHeadlessInitialization();
+    mockBueno();
   });
 
   afterEach(() => {
@@ -198,6 +221,90 @@ describe('c-quantic-category-facet', () => {
     });
   });
 
+  describe('validation of the dependsOn property', () => {
+    let consoleError;
+    beforeAll(() => {
+      consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
+    });
+
+    describe('when dependsOn.parentFacetId is not provided', () => {
+      it('should display the error component', async () => {
+        const invalidFacetDependency = {
+          expectedValue: 'txt',
+        };
+        const element = createTestComponent({
+          ...defaultOptions,
+          dependsOn: invalidFacetDependency,
+        });
+        await flushPromises();
+
+        const componentError = element.shadowRoot.querySelector(
+          selectors.componentError
+        );
+        const facetContent = element.shadowRoot.querySelector(
+          selectors.facetContent
+        );
+
+        expect(consoleError).toHaveBeenCalledTimes(1);
+        expect(consoleError).toHaveBeenCalledWith(parentFacetIdError);
+        expect(componentError).not.toBeNull();
+        expect(facetContent).toBeNull();
+      });
+    });
+
+    describe('when dependsOn.parentFacetId is not a string', () => {
+      it('should display the error component', async () => {
+        const invalidFacetDependency = {
+          parentFacetId: 1,
+          expectedValue: 'txt',
+        };
+        const element = createTestComponent({
+          ...defaultOptions,
+          dependsOn: invalidFacetDependency,
+        });
+        await flushPromises();
+
+        const componentError = element.shadowRoot.querySelector(
+          selectors.componentError
+        );
+        const facetContent = element.shadowRoot.querySelector(
+          selectors.facetContent
+        );
+
+        expect(consoleError).toHaveBeenCalledTimes(1);
+        expect(consoleError).toHaveBeenCalledWith(parentFacetIdError);
+        expect(componentError).not.toBeNull();
+        expect(facetContent).toBeNull();
+      });
+    });
+
+    describe('when dependsOn.expectedValue is not a string', () => {
+      it('should display the error component', async () => {
+        const invalidFacetDependency = {
+          parentFacetId: 'filetype',
+          expectedValue: 2,
+        };
+        const element = createTestComponent({
+          ...defaultOptions,
+          dependsOn: invalidFacetDependency,
+        });
+        await flushPromises();
+
+        const componentError = element.shadowRoot.querySelector(
+          selectors.componentError
+        );
+        const facetContent = element.shadowRoot.querySelector(
+          selectors.facetContent
+        );
+
+        expect(consoleError).toHaveBeenCalledTimes(1);
+        expect(consoleError).toHaveBeenCalledWith(expectedValueError);
+        expect(componentError).not.toBeNull();
+        expect(facetContent).toBeNull();
+      });
+    });
+  });
+
   describe('when the component is disconnected', () => {
     it('should make the condition manager stop watching the facet', async () => {
       const exampleFacetDependency = {

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

@@ -14,6 +14,7 @@ import {
   initializeWithHeadless,
   registerToStore,
   getHeadlessBundle,
+  getBueno,
 } from 'c/quanticHeadlessLoader';
 import {
   I18nUtils,
@@ -301,6 +302,7 @@ export default class QuanticCategoryFacet extends LightningElement {
       },
     });
     if (this.dependsOn) {
+      this.validateDependsOnProperty();
       this.initFacetConditionManager(engine);
     }
     this.unsubscribe = this.facet.subscribe(() => this.updateState());
@@ -330,6 +332,26 @@ export default class QuanticCategoryFacet extends LightningElement {
     this.dispatchEvent(renderFacetEvent);
   }
 
+  validateDependsOnProperty() {
+    if (this.dependsOn) {
+      getBueno(this).then(() => {
+        const {parentFacetId, expectedValue} = this.dependsOn;
+        if (!Bueno.isString(parentFacetId)) {
+          console.error(
+            `The ${this.field} ${this.template.host.localName} requires dependsOn.parentFacetId to be a valid string.`
+          );
+          this.setInitializationError();
+        }
+        if (expectedValue && !Bueno.isString(expectedValue)) {
+          console.error(
+            `The ${this.field} ${this.template.host.localName} requires dependsOn.expectedValue to be a valid string.`
+          );
+          this.setInitializationError();
+        }
+      });
+    }
+  }
+
   initFacetConditionManager(engine) {
     this.categoryFacetConditionsManager =
       this.headless.buildFacetConditionsManager(engine, {

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

@@ -12,16 +12,21 @@ jest.mock('c/quanticUtils', () => ({
       DATEFACETS: 'dateFacets',
     },
   },
+  I18nUtils: {
+    format: jest.fn(),
+  },
 }));
 jest.mock('c/quanticHeadlessLoader');
 
 const selectors = {
   facetContent: '[data-test="facet-content"]',
+  componentError: 'c-quantic-component-error',
 };
 
 const exampleFacetId = 'example facet id';
+const exampleField = 'exampleField';
 const defaultOptions = {
-  field: 'example field',
+  field: exampleField,
 };
 const dateFacetControllerMock = {
   subscribe: jest.fn((callback) => callback()),
@@ -30,6 +35,8 @@ const dateFacetControllerMock = {
     values: [],
   },
 };
+const parentFacetIdError = `The ${exampleField} c-quantic-date-facet requires dependsOn.parentFacetId to be a valid string.`;
+const expectedValueError = `The ${exampleField} c-quantic-date-facet requires dependsOn.expectedValue to be a valid string.`;
 
 function createTestComponent(options = defaultOptions) {
   prepareHeadlessState();
@@ -79,6 +86,21 @@ const exampleEngine = {
 };
 let isInitialized = false;
 
+function mockBueno() {
+  // @ts-ignore
+  mockHeadlessLoader.getBueno = () => {
+    // @ts-ignore
+    global.Bueno = {
+      isString: jest
+        .fn()
+        .mockImplementation(
+          (value) => Object.prototype.toString.call(value) === '[object String]'
+        ),
+    };
+    return new Promise((resolve) => resolve());
+  };
+}
+
 function mockSuccessfulHeadlessInitialization() {
   // @ts-ignore
   mockHeadlessLoader.initializeWithHeadless = (element, _, initialize) => {
@@ -101,6 +123,7 @@ function cleanup() {
 describe('c-quantic-date-facet', () => {
   beforeAll(() => {
     mockSuccessfulHeadlessInitialization();
+    mockBueno();
   });
 
   afterEach(() => {
@@ -193,6 +216,89 @@ describe('c-quantic-date-facet', () => {
     });
   });
 
+  describe('validation of the dependsOn property', () => {
+    let consoleError;
+    beforeAll(() => {
+      consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
+    });
+    describe('when dependsOn.parentFacetId is not provided', () => {
+      it('should display the error component', async () => {
+        const invalidFacetDependency = {
+          expectedValue: 'txt',
+        };
+        const element = createTestComponent({
+          ...defaultOptions,
+          dependsOn: invalidFacetDependency,
+        });
+        await flushPromises();
+
+        const componentError = element.shadowRoot.querySelector(
+          selectors.componentError
+        );
+        const facetContent = element.shadowRoot.querySelector(
+          selectors.facetContent
+        );
+
+        expect(consoleError).toHaveBeenCalledTimes(1);
+        expect(consoleError).toHaveBeenCalledWith(parentFacetIdError);
+        expect(componentError).not.toBeNull();
+        expect(facetContent).toBeNull();
+      });
+    });
+
+    describe('when dependsOn.parentFacetId is not a string', () => {
+      it('should display the error component', async () => {
+        const invalidFacetDependency = {
+          parentFacetId: 1,
+          expectedValue: 'txt',
+        };
+        const element = createTestComponent({
+          ...defaultOptions,
+          dependsOn: invalidFacetDependency,
+        });
+        await flushPromises();
+
+        const componentError = element.shadowRoot.querySelector(
+          selectors.componentError
+        );
+        const facetContent = element.shadowRoot.querySelector(
+          selectors.facetContent
+        );
+
+        expect(consoleError).toHaveBeenCalledTimes(1);
+        expect(consoleError).toHaveBeenCalledWith(parentFacetIdError);
+        expect(componentError).not.toBeNull();
+        expect(facetContent).toBeNull();
+      });
+    });
+
+    describe('when dependsOn.expectedValue is not a string', () => {
+      it('should display the error component', async () => {
+        const invalidFacetDependency = {
+          parentFacetId: 'filetype',
+          expectedValue: 2,
+        };
+        const element = createTestComponent({
+          ...defaultOptions,
+          dependsOn: invalidFacetDependency,
+        });
+        await flushPromises();
+
+        const componentError = element.shadowRoot.querySelector(
+          selectors.componentError
+        );
+        const facetContent = element.shadowRoot.querySelector(
+          selectors.facetContent
+        );
+
+        expect(consoleError).toHaveBeenCalledTimes(1);
+        expect(consoleError).toHaveBeenCalledWith(expectedValueError);
+        expect(componentError).not.toBeNull();
+        expect(facetContent).toBeNull();
+      });
+    });
+  });
+
   describe('when the component is disconnected', () => {
     it('should make the condition manager stop watching the facet', async () => {
       const exampleFacetDependency = {

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

@@ -9,6 +9,7 @@ import {
   initializeWithHeadless,
   registerToStore,
   getHeadlessBundle,
+  getBueno,
 } from 'c/quanticHeadlessLoader';
 import {
   I18nUtils,
@@ -210,6 +211,7 @@ export default class QuanticDateFacet extends LightningElement {
       element: this.template.host,
     });
     if (this.dependsOn) {
+      this.validateDependsOnProperty();
       this.initFacetConditionManager(engine);
     }
   };
@@ -238,6 +240,26 @@ export default class QuanticDateFacet extends LightningElement {
     this.dispatchEvent(renderFacetEvent);
   }
 
+  validateDependsOnProperty() {
+    if (this.dependsOn) {
+      getBueno(this).then(() => {
+        const {parentFacetId, expectedValue} = this.dependsOn;
+        if (!Bueno.isString(parentFacetId)) {
+          console.error(
+            `The ${this.field} ${this.template.host.localName} requires dependsOn.parentFacetId to be a valid string.`
+          );
+          this.setInitializationError();
+        }
+        if (expectedValue && !Bueno.isString(expectedValue)) {
+          console.error(
+            `The ${this.field} ${this.template.host.localName} requires dependsOn.expectedValue to be a valid string.`
+          );
+          this.setInitializationError();
+        }
+      });
+    }
+  }
+
   initFacetConditionManager(engine) {
     this.dateFacetConditionsManager = this.headless.buildFacetConditionsManager(
       engine,

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

@@ -0,0 +1,199 @@
+/* eslint-disable no-import-assign */
+// @ts-ignore
+import {createElement} from 'lwc';
+import QuanticDidYouMean from '../quanticDidYouMean';
+import * as mockHeadlessLoader from 'c/quanticHeadlessLoader';
+
+jest.mock('c/quanticHeadlessLoader');
+
+let isInitialized = false;
+
+const exampleEngine = {
+  id: 'exampleEngineId',
+};
+
+const defaultQueryCorrectionMode = 'legacy';
+
+const defaultOptions = {
+  engineId: exampleEngine.id,
+  disableQueryAutoCorrection: false,
+  queryCorrectionMode: defaultQueryCorrectionMode,
+};
+
+const mockDidYouMeanState = {
+  wasCorrectedTo: 'example corrected query',
+  originalQuery: 'example original query',
+  wasAutomaticallyCorrected: true,
+  queryCorrection: {
+    correctedQuery: 'example corrected query',
+    wordCorrected: 'example',
+  },
+  hasQueryCorrection: true,
+};
+
+const functionsMocks = {
+  buildDidYouMean: jest.fn(() => ({
+    state: mockDidYouMeanState,
+    subscribe: functionsMocks.subscribe,
+  })),
+  buildQueryTrigger: jest.fn(() => ({
+    state: {},
+    subscribe: functionsMocks.subscribe,
+  })),
+  applyCorrection: jest.fn(() => {}),
+  subscribe: jest.fn((cb) => {
+    cb();
+    return functionsMocks.unsubscribe;
+  }),
+  unsubscribe: jest.fn(() => {}),
+};
+
+function prepareHeadlessState() {
+  // @ts-ignore
+  mockHeadlessLoader.getHeadlessBundle = () => {
+    return {
+      buildDidYouMean: functionsMocks.buildDidYouMean,
+      buildQueryTrigger: functionsMocks.buildQueryTrigger,
+    };
+  };
+}
+
+function mockSuccessfulHeadlessInitialization() {
+  // @ts-ignore
+  mockHeadlessLoader.initializeWithHeadless = (element, _, initialize) => {
+    if (element instanceof QuanticDidYouMean && !isInitialized) {
+      isInitialized = true;
+      initialize(exampleEngine);
+    }
+  };
+}
+
+function createTestComponent(options = defaultOptions) {
+  prepareHeadlessState();
+  const element = createElement('c-quantic-did-you-mean', {
+    is: QuanticDidYouMean,
+  });
+
+  for (const [key, value] of Object.entries(options)) {
+    element[key] = value;
+  }
+
+  document.body.appendChild(element);
+  return element;
+}
+
+// Helper function to wait until the microtask queue is empty.
+async function flushPromises() {
+  return Promise.resolve();
+}
+
+describe('c-quantic-did-you-mean', () => {
+  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;
+  }
+
+  beforeEach(() => {
+    mockSuccessfulHeadlessInitialization();
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+
+  describe('controller initialization', () => {
+    it('should subscribe to the headless state changes', async () => {
+      createTestComponent();
+      await flushPromises();
+
+      expect(functionsMocks.buildDidYouMean).toHaveBeenCalled();
+      expect(functionsMocks.subscribe).toHaveBeenCalled();
+    });
+
+    describe('#disableQueryAutoCorrection property', () => {
+      describe('when disableQueryAutoCorrection is false (default)', () => {
+        it('should properly initialize the controller with automatic query correction enabled', async () => {
+          createTestComponent();
+          await flushPromises();
+
+          expect(functionsMocks.buildDidYouMean).toHaveBeenCalledTimes(1);
+          expect(functionsMocks.buildDidYouMean).toHaveBeenCalledWith(
+            exampleEngine,
+            expect.objectContaining({
+              options: expect.objectContaining({
+                automaticallyCorrectQuery: true,
+                queryCorrectionMode: defaultQueryCorrectionMode,
+              }),
+            })
+          );
+        });
+      });
+
+      describe('when disableQueryAutoCorrection is true', () => {
+        it('should properly initialize the controller with automatic query correction disabled', async () => {
+          createTestComponent({
+            ...defaultOptions,
+            disableQueryAutoCorrection: true,
+          });
+          await flushPromises();
+
+          expect(functionsMocks.buildDidYouMean).toHaveBeenCalledTimes(1);
+          expect(functionsMocks.buildDidYouMean).toHaveBeenCalledWith(
+            exampleEngine,
+            expect.objectContaining({
+              options: expect.objectContaining({
+                automaticallyCorrectQuery: false,
+                queryCorrectionMode: defaultQueryCorrectionMode,
+              }),
+            })
+          );
+        });
+      });
+    });
+
+    describe('#queryCorrectionMode property', () => {
+      describe('when queryCorrectionMode is `legacy` (default)', () => {
+        it('should properly initialize the controller with the query correction mode set to `legacy`', async () => {
+          createTestComponent();
+          await flushPromises();
+
+          expect(functionsMocks.buildDidYouMean).toHaveBeenCalledTimes(1);
+          expect(functionsMocks.buildDidYouMean).toHaveBeenCalledWith(
+            exampleEngine,
+            expect.objectContaining({
+              options: expect.objectContaining({
+                automaticallyCorrectQuery: true,
+                queryCorrectionMode: defaultQueryCorrectionMode,
+              }),
+            })
+          );
+        });
+      });
+
+      describe('when queryCorrectionMode is `next`', () => {
+        it('should properly initialize the controller with the query correction mode set to `next`', async () => {
+          createTestComponent({
+            ...defaultOptions,
+            queryCorrectionMode: 'next',
+          });
+          await flushPromises();
+
+          expect(functionsMocks.buildDidYouMean).toHaveBeenCalledTimes(1);
+          expect(functionsMocks.buildDidYouMean).toHaveBeenCalledWith(
+            exampleEngine,
+            expect.objectContaining({
+              options: expect.objectContaining({
+                automaticallyCorrectQuery: true,
+                queryCorrectionMode: 'next',
+              }),
+            })
+          );
+        });
+      });
+    });
+  });
+});