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

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/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',
+              }),
+            })
+          );
+        });
+      });
+    });
+  });
+});

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

@@ -29,7 +29,7 @@ import queryTriggerTemplate from './templates/queryTrigger.html';
  * @category Search
  * @category Insight Panel
  * @example
- * <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>
  */
 export default class QuanticDidYouMean extends LightningElement {
   /**
@@ -38,6 +38,25 @@ export default class QuanticDidYouMean extends LightningElement {
    * @type {string}
    */
   @api engineId;
+  /**
+   * Whether to disable automatically applying corrections for queries that would otherwise return no results.
+   * When `disableQueryAutoCorrection` is `false`, the component automatically triggers a new query using the suggested term.
+   * When `disableQueryAutoCorrection` is `true`, the component returns the suggested term without triggering a new query.
+   * @api
+   * @type {boolean}
+   * @defaultValue false
+   */
+  @api disableQueryAutoCorrection = false;
+  /**
+   * Defines which query correction system to use.
+   * `legacy`: 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.
+   * `next`: 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.
+   * The `legacy` system will send two requests to the API to get the suggestions, while the `next` system will send one request.
+   * @api
+   * @type {string}
+   * @defaultValue 'legacy'
+   */
+  @api queryCorrectionMode = 'legacy';
 
   /** @type {boolean}*/
   @track hasQueryCorrection;
@@ -85,7 +104,10 @@ export default class QuanticDidYouMean extends LightningElement {
   initialize = (engine) => {
     this.headless = getHeadlessBundle(this.engineId);
     this.didYouMean = this.headless.buildDidYouMean(engine, {
-      options: {queryCorrectionMode: 'legacy'},
+      options: {
+        queryCorrectionMode: this.queryCorrectionMode,
+        automaticallyCorrectQuery: !this.disableQueryAutoCorrection,
+      },
     });
     this.queryTrigger = this.headless?.buildQueryTrigger?.(engine);
     this.unsubscribeDidYouMean = this.didYouMean.subscribe(() =>