@coveo/quantic 3.13.1 → 3.14.0

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

@@ -31,14 +31,28 @@ export default class QuanticResultsPerPage extends LightningElement {
    * @type {string}
    * @defaultValue `'10,25,50,100'`
    */
-  @api choicesDisplayed = '10,25,50,100';
+  @api
+  get choicesDisplayed() {
+    return this._choicesDisplayed;
+  }
+  set choicesDisplayed(value) {
+    if (this.validateChoicesDisplayed(value)) {
+      this._choicesDisplayed = value;
+    }
+  }
   /**
    * The initial selection for the number of result per page. This should be part of the `choicesDisplayed` option. By default, this is set to the first value in `choicesDisplayed`.
    * @api
    * @type {number}
-   * @defaultValue `10`
+   * @defaultValue `the first value in 'choicesDisplayed'`
    */
-  @api initialChoice = 10;
+  @api
+  get initialChoice() {
+    return this._initialChoice;
+  }
+  set initialChoice(value) {
+    this._initialChoice = value;
+  }
 
   /** @type {boolean}*/
   @track hasResults;
@@ -59,12 +73,21 @@ export default class QuanticResultsPerPage extends LightningElement {
   headless;
   /** @type {boolean} */
   hasInitializationError = false;
+  /** @type {number} */
+  _initialChoice;
+  /** @type {string} */
+  _choicesDisplayed = '10,25,50,100';
 
   labels = {
     showNResultsPerPage,
   };
 
   connectedCallback() {
+    this.choices = this.parseChoicesDisplayed();
+    if (!this._initialChoice) {
+      this._initialChoice = this.choices[0];
+    }
+    this.validateInitialChoice();
     registerComponentForInit(this, this.engineId);
   }
 
@@ -77,8 +100,6 @@ export default class QuanticResultsPerPage extends LightningElement {
    */
   initialize = (engine) => {
     this.headless = getHeadlessBundle(this.engineId);
-    this.choices = this.parseChoicesDisplayed();
-    this.validateInitialChoice();
     this.resultsPerPage = this.headless.buildResultsPerPage(engine, {
       initialState: {
         numberOfResults: Number(this.initialChoice) ?? this.choices[0],
@@ -105,19 +126,33 @@ export default class QuanticResultsPerPage extends LightningElement {
     return this.choicesDisplayed.split(',').map((choice) => {
       const parsedChoice = parseInt(choice, 10);
       if (isNaN(parsedChoice)) {
-        throw new Error(
+        this.setInitializationError();
+      }
+      return parsedChoice;
+    });
+  }
+
+  validateChoicesDisplayed(value) {
+    let valid = true;
+    value.split(',').forEach((choice) => {
+      const parsedChoice = parseInt(choice, 10);
+      if (isNaN(parsedChoice)) {
+        console.error(
           `The choice value "${choice}" from the "choicesDisplayed" option is not a number.`
         );
+        this.setInitializationError();
+        valid = false;
       }
-      return parsedChoice;
     });
+    return valid;
   }
 
   validateInitialChoice() {
     if (!this.choices.includes(Number(this.initialChoice))) {
-      throw new Error(
-        `The "initialChoice" option value "${this.initialChoice}" is not included in the "choicesDisplayed" option "${this.choicesDisplayed}".`
+      console.error(
+        `The "initialChoice" option value "${this.initialChoice}" is not included in the "choicesDisplayed" option "${this.choicesDisplayed}". Defaulting to the first value of the choices.`
       );
+      this._initialChoice = this.choices[0];
     }
   }
 

package/force-app/main/default/lwc/quanticSmartSnippet/e2e/data.ts

@@ -1,3 +1,5 @@
+import {QuestionAnswerData} from '../../../../../../playwright/page-object/searchObjectWithSmartSnippet';
+
 const exampleQuestion = 'Where was Gondor when the Westfold fell?';
 const exampleAnswerSnippet = `<a href="#">Gondor</a> was on the brink of destruction when the Westfold fell. Gondor did not come to Rohan's aid when the Westfold fell because it was overwhelmed by its own dire circumstances and unable to spare resources or manpower. The alliance between the two kingdoms, forged by the Oath of Eorl, was based on a promise of mutual defense in times of extreme need. However, by the time of the War of the Ring, Gondor was facing unprecedented threats from Sauron, whose forces in Mordor were massing for a full-scale assault on Minas Tirith. The Steward of Gondor, Denethor II, was deeply concerned about the security of his own kingdom and could not afford to weaken its defenses to send aid across the vast distances that separated Gondor from the Westfold. Even if assistance had been feasible, the logistical challenge of moving troops through potentially hostile territory would have delayed their arrival, rendering their efforts ineffective. Moreover, the threat to Rohan came not only from Sauron's influence but also from the unexpected betrayal of Saruman, who, until then, had been perceived as an ally. His treachery, combined with the swiftness and brutality of his attacks, left Rohan vulnerable and isolated, as neither Rohan nor Gondor had anticipated such aggression from Isengard. While the alliance between the two realms remained strong in spirit, Gondor's immediate need to safeguard its own survival against the growing shadow of Mordor took precedence, leaving Rohan to fend for itself during the fall of the Westfold.`;
 const exampleScore = 0.42;
@@ -5,17 +7,6 @@ const exampleContentIdKey = 'permanentid';
 const mockPermanentId = '1234';
 const exampleContentIdValue = mockPermanentId;
 
-export type QuestionAnswerData = {
-  answerFound: boolean;
-  question: string;
-  answerSnippet: string;
-  documentId: {
-    contentIdKey: string;
-    contentIdValue: string;
-  };
-  score: number;
-};
-
 const smartSnippetData: QuestionAnswerData = {
   answerFound: true,
   question: exampleQuestion,

package/force-app/main/default/lwc/quanticSmartSnippet/e2e/fixture.ts

@@ -1,13 +1,15 @@
 import {SmartSnippetObject} from './pageObject';
 import {quanticBase} from '../../../../../../playwright/fixtures/baseFixture';
-import {SearchObject} from '../../../../../../playwright/page-object/searchObject';
+import {
+  SearchObjectWithSmartSnippet,
+  QuestionAnswerData,
+} from '../../../../../../playwright/page-object/searchObjectWithSmartSnippet';
 import {
   searchRequestRegex,
   insightSearchRequestRegex,
 } from '../../../../../../playwright/utils/requests';
 import {InsightSetupObject} from '../../../../../../playwright/page-object/insightSetupObject';
 import {useCaseEnum} from '../../../../../../playwright/utils/useCase';
-import type {QuestionAnswerData} from './data';
 import smartSnippetData from './data';
 
 const pageUrl = 's/quantic-smart-snippet';
@@ -19,7 +21,7 @@ interface SmartSnippetOptions {
 type QuanticSmartSnippetE2ESearchFixtures = {
   smartSnippetData: QuestionAnswerData;
   smartSnippet: SmartSnippetObject;
-  search: SearchObject;
+  search: SearchObjectWithSmartSnippet;
   options: Partial<SmartSnippetOptions>;
 };
 
@@ -33,7 +35,7 @@ export const testSearch =
     smartSnippetData,
     options: {},
     search: async ({page}, use) => {
-      await use(new SearchObject(page, searchRequestRegex));
+      await use(new SearchObjectWithSmartSnippet(page, searchRequestRegex));
     },
     smartSnippet: async (
       {page, options, configuration, search, smartSnippetData: data},
@@ -55,7 +57,9 @@ export const testInsight =
     smartSnippetData,
     options: {},
     search: async ({page}, use) => {
-      await use(new SearchObject(page, insightSearchRequestRegex));
+      await use(
+        new SearchObjectWithSmartSnippet(page, insightSearchRequestRegex)
+      );
     },
     insightSetup: async ({page}, use) => {
       await use(new InsightSetupObject(page));

package/force-app/main/default/lwc/quanticSmartSnippet/e2e/pageObject.ts

@@ -22,7 +22,7 @@ export class SmartSnippetObject {
   }
 
   get smartSnippetAnwerInlineLink(): Locator {
-    return this.page.locator('.smart-snippet-answer a');
+    return this.page.locator('[data-testid="smart-snippet-answer"] > a');
   }
 
   get smartSnippetToggleButton(): Locator {

package/force-app/main/default/lwc/quanticSmartSnippetAnswer/quanticSmartSnippetAnswer.html

@@ -1,3 +1,3 @@
 <template>
-  <div data-cy="smart-snippet-answer" class="smart-snippet-answer" lwc:dom="manual"></div>
+  <div data-testid="smart-snippet-answer" class="smart-snippet-answer" lwc:dom="manual"></div>
 </template>

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

@@ -0,0 +1,329 @@
+/* eslint-disable no-import-assign */
+import QuanticSmartSnippetSuggestions from '../quanticSmartSnippetSuggestions';
+// @ts-ignore
+import {createElement} from 'lwc';
+import * as mockHeadlessLoader from 'c/quanticHeadlessLoader';
+
+jest.mock('c/quanticHeadlessLoader');
+
+jest.mock(
+  '@salesforce/label/c.quantic_PeopleAlsoAsk',
+  () => ({default: 'People also ask'}),
+  {
+    virtual: true,
+  }
+);
+
+let isInitialized = false;
+
+const exampleEngine = {
+  id: 'exampleEngineId',
+};
+
+const exampleUri = 'https://en.wikipedia.org/wiki/The_Lord_of_the_Rings';
+
+const defaultOptions = {
+  engineId: exampleEngine.id,
+};
+
+const selectors = {
+  initializationError: 'c-quantic-component-error',
+  smartSnippetSuggestionsComponent:
+    '[data-testid="smart-snippet-suggestions-card"]',
+  smartSnippetSuggestions: '[data-testid="smart-snippet-suggestion"]',
+  smartSnippetSuggestionAnswers: 'c-quantic-smart-snippet-answer',
+  smartSnippetSuggestionSources: 'c-quantic-smart-snippet-source',
+  smartSnippetAccordionElement: 'lightning-accordion',
+};
+
+const mockSmartSnippetSource = {
+  title: 'The Lord of the Rings',
+  uri: exampleUri,
+  clickUri: exampleUri,
+};
+
+const mockSmartSnippetRelatedQuestions = [
+  {
+    question: 'Where is Gandalf?',
+    answer: 'Gandalf is in the Mines of Moria.',
+    documentId: {
+      contentIdKey: '2',
+      contentIdValue: '2',
+    },
+    questionAnswerId: '2',
+    expanded: false,
+    source: mockSmartSnippetSource,
+    score: 0.5,
+  },
+  {
+    question: 'Legolas, what do you see?',
+    answer: "They're taking the hobbits to Isengard!",
+    documentId: {
+      contentIdKey: '3',
+      contentIdValue: '3',
+    },
+    questionAnswerId: '3',
+    expanded: false,
+    source: mockSmartSnippetSource,
+    score: 0.5,
+  },
+];
+
+const defaultSmartSnippetSuggestionsState = {
+  questions: mockSmartSnippetRelatedQuestions,
+};
+
+let smartSnippetSuggestionsState = defaultSmartSnippetSuggestionsState;
+
+const functionsMocks = {
+  buildSmartSnippetQuestionsList: jest.fn(() => ({
+    state: smartSnippetSuggestionsState,
+    subscribe: functionsMocks.smartSnippetSuggestionsStateSubscriber,
+    expand: functionsMocks.expand,
+    collapse: functionsMocks.collapse,
+    select: functionsMocks.select,
+    beginDelayedSelect: functionsMocks.beginDelayedSelect,
+    cancelPendingSelect: functionsMocks.cancelPendingSelect,
+    selectInlineLink: functionsMocks.selectInlineLink,
+    beginDelayedSelectInlineLink: functionsMocks.beginDelayedSelectInlineLink,
+    cancelPendingSelectInlineLink: functionsMocks.cancelPendingSelectInlineLink,
+  })),
+  smartSnippetSuggestionsStateSubscriber: jest.fn((cb) => {
+    cb();
+    return functionsMocks.smartSnippetSuggestionsStateUnsubscriber;
+  }),
+  smartSnippetSuggestionsStateUnsubscriber: jest.fn(),
+  expand: jest.fn(),
+  collapse: jest.fn(),
+  select: jest.fn(),
+  beginDelayedSelect: jest.fn(),
+  cancelPendingSelect: jest.fn(),
+  selectInlineLink: jest.fn(),
+  beginDelayedSelectInlineLink: jest.fn(),
+  cancelPendingSelectInlineLink: jest.fn(),
+};
+
+function createTestComponent(options = defaultOptions) {
+  const element = createElement('c-quantic-smart-snippet-suggestions', {
+    is: QuanticSmartSnippetSuggestions,
+  });
+  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.
+function flushPromises() {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+function prepareHeadlessState() {
+  // @ts-ignore
+  mockHeadlessLoader.getHeadlessBundle = () => {
+    return {
+      buildSmartSnippetQuestionsList:
+        functionsMocks.buildSmartSnippetQuestionsList,
+    };
+  };
+}
+
+function mockSuccessfulHeadlessInitialization() {
+  // @ts-ignore
+  mockHeadlessLoader.initializeWithHeadless = (element, _, initialize) => {
+    if (element instanceof QuanticSmartSnippetSuggestions && !isInitialized) {
+      isInitialized = true;
+      initialize(exampleEngine);
+    }
+  };
+}
+
+function mockErroneousHeadlessInitialization() {
+  // @ts-ignore
+  mockHeadlessLoader.initializeWithHeadless = (element) => {
+    if (element instanceof QuanticSmartSnippetSuggestions) {
+      element.setInitializationError();
+    }
+  };
+}
+
+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-smart-snippet-suggestions', () => {
+  afterEach(() => {
+    smartSnippetSuggestionsState = defaultSmartSnippetSuggestionsState;
+    cleanup();
+  });
+
+  describe('controller initialization', () => {
+    beforeEach(() => {
+      mockSuccessfulHeadlessInitialization();
+      prepareHeadlessState();
+    });
+
+    it('should build the smart snippet controller with the proper parameters and subscribe to its state change', async () => {
+      createTestComponent();
+      await flushPromises();
+
+      expect(
+        functionsMocks.buildSmartSnippetQuestionsList
+      ).toHaveBeenCalledTimes(1);
+      expect(
+        functionsMocks.buildSmartSnippetQuestionsList
+      ).toHaveBeenCalledWith(exampleEngine);
+      expect(
+        functionsMocks.smartSnippetSuggestionsStateSubscriber
+      ).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('when an initialization error occurs', () => {
+    beforeEach(() => {
+      mockErroneousHeadlessInitialization();
+    });
+
+    it('should display the initialization error component', async () => {
+      const element = createTestComponent();
+      await flushPromises();
+
+      const initializationError = element.shadowRoot.querySelector(
+        selectors.initializationError
+      );
+
+      expect(initializationError).not.toBeNull();
+    });
+  });
+
+  describe('when the query does not return smart snippet suggestions', () => {
+    beforeEach(() => {
+      smartSnippetSuggestionsState = {
+        ...defaultSmartSnippetSuggestionsState,
+        questions: [],
+      };
+      mockSuccessfulHeadlessInitialization();
+      prepareHeadlessState();
+    });
+
+    it('should not display the smart snippet suggestions component', async () => {
+      const element = createTestComponent();
+      await flushPromises();
+
+      const smartSnippetSuggestionsComponent = element.shadowRoot.querySelector(
+        selectors.smartSnippetSuggestionsComponent
+      );
+      expect(smartSnippetSuggestionsComponent).toBeNull();
+    });
+  });
+
+  describe('when the query returns smart snippet suggestions', () => {
+    beforeEach(() => {
+      mockSuccessfulHeadlessInitialization();
+      prepareHeadlessState();
+    });
+
+    it('should properly display the smart snippet suggestions', async () => {
+      const element = createTestComponent();
+      await flushPromises();
+
+      const smartSnippetSuggestionsComponent = element.shadowRoot.querySelector(
+        selectors.smartSnippetSuggestionsComponent
+      );
+      expect(smartSnippetSuggestionsComponent).not.toBeNull();
+
+      const smartSnippetSuggestions = element.shadowRoot.querySelectorAll(
+        selectors.smartSnippetSuggestions
+      );
+      const smartSnippetSuggestionAnswers = element.shadowRoot.querySelectorAll(
+        selectors.smartSnippetSuggestionAnswers
+      );
+      const smartSnippetSuggestionsSources =
+        element.shadowRoot.querySelectorAll(
+          selectors.smartSnippetSuggestionSources
+        );
+
+      mockSmartSnippetRelatedQuestions.forEach((question, index) => {
+        const suggestion = smartSnippetSuggestions[index];
+        const answerElement = smartSnippetSuggestionAnswers[index];
+        const sourceElement = smartSnippetSuggestionsSources[index];
+
+        expect(suggestion.label).toEqual(question.question);
+        expect(answerElement.answer).toEqual(question.answer);
+        expect(sourceElement.source).toEqual(question.source);
+      });
+    });
+
+    describe('when clicking on the smart snippet suggestion', () => {
+      it('should call the expand and collapse methods from the smartSnippetSuggestions controller', async () => {
+        const element = createTestComponent();
+        await flushPromises();
+
+        const smartSnippetAccordionElement = element.shadowRoot.querySelector(
+          selectors.smartSnippetAccordionElement
+        );
+        expect(smartSnippetAccordionElement).not.toBeNull();
+        smartSnippetAccordionElement.activeSectionName = [
+          mockSmartSnippetRelatedQuestions[0].question,
+        ];
+
+        const smartSnippetSuggestionsItems =
+          element.shadowRoot.querySelectorAll(
+            selectors.smartSnippetSuggestions
+          );
+        expect(smartSnippetSuggestionsItems[0]).not.toBeNull();
+
+        await smartSnippetSuggestionsItems[0].click();
+        await flushPromises();
+
+        expect(functionsMocks.expand).toHaveBeenCalledTimes(1);
+        expect(functionsMocks.expand).toHaveBeenCalledWith(
+          mockSmartSnippetRelatedQuestions[0].questionAnswerId
+        );
+
+        smartSnippetAccordionElement.activeSectionName = [];
+        await smartSnippetSuggestionsItems[0].click();
+        await flushPromises();
+
+        expect(functionsMocks.collapse).toHaveBeenCalledTimes(1);
+        expect(functionsMocks.collapse).toHaveBeenCalledWith(
+          mockSmartSnippetRelatedQuestions[0].questionAnswerId
+        );
+      });
+    });
+
+    it('should pass the proper actions to the smart snippet answer and source', async () => {
+      const element = createTestComponent();
+      await flushPromises();
+
+      const smartSnippetAnswer = element.shadowRoot.querySelector(
+        selectors.smartSnippetSuggestionAnswers
+      );
+      const smartSnippetSource = element.shadowRoot.querySelector(
+        selectors.smartSnippetSuggestionSources
+      );
+
+      expect(smartSnippetAnswer).not.toBeNull();
+      expect(smartSnippetSource).not.toBeNull();
+
+      const expectedSmartSnippetSuggestionsActions = {
+        select: functionsMocks.select,
+        beginDelayedSelect: functionsMocks.beginDelayedSelect,
+        cancelPendingSelect: functionsMocks.cancelPendingSelect,
+      };
+
+      expect(Object.keys(smartSnippetAnswer.actions)).toEqual(
+        Object.keys(expectedSmartSnippetSuggestionsActions)
+      );
+      expect(Object.keys(smartSnippetSource.actions)).toEqual(
+        Object.keys(expectedSmartSnippetSuggestionsActions)
+      );
+    });
+  });
+});

package/force-app/main/default/lwc/quanticSmartSnippetSuggestions/e2e/data.ts

@@ -0,0 +1,31 @@
+import {RelatedQuestionsData} from '../../../../../../playwright/page-object/searchObjectWithSmartSnippet';
+
+const exampleContentIdKey = 'permanentid';
+const mockPermanentId = '1234';
+const exampleContentIdValue = mockPermanentId;
+
+const exampleRelatedQuestions = [
+  {
+    question: "What is the name of Gandalf's horse?",
+    answerSnippet:
+      'Is is Shadowfax, the lord of all horses. <a href="#">Click here to see the magnificent horse.</a>',
+    documentId: {
+      contentIdKey: exampleContentIdKey,
+      contentIdValue: exampleContentIdValue,
+    },
+  },
+  {
+    question: 'What is the name of the sword that was broken?',
+    answerSnippet: 'It is Narsil, the sword of Elendil.',
+    documentId: {
+      contentIdKey: exampleContentIdKey,
+      contentIdValue: exampleContentIdValue,
+    },
+  },
+];
+
+const smartSnippetSuggestionsData: RelatedQuestionsData = {
+  relatedQuestions: exampleRelatedQuestions,
+};
+
+export default smartSnippetSuggestionsData;

package/force-app/main/default/lwc/quanticSmartSnippetSuggestions/e2e/fixture.ts

@@ -0,0 +1,93 @@
+import {SmartSnippetSuggestionsObject} from './pageObject';
+import {quanticBase} from '../../../../../../playwright/fixtures/baseFixture';
+import {
+  SearchObjectWithSmartSnippet,
+  RelatedQuestionsData,
+} from '../../../../../../playwright/page-object/searchObjectWithSmartSnippet';
+import {
+  searchRequestRegex,
+  insightSearchRequestRegex,
+} from '../../../../../../playwright/utils/requests';
+import {InsightSetupObject} from '../../../../../../playwright/page-object/insightSetupObject';
+import {useCaseEnum} from '../../../../../../playwright/utils/useCase';
+import smartSnippetSuggestionsData from './data';
+
+const pageUrl = 's/quantic-smart-snippet-suggestions';
+
+interface SmartSnippetSuggestionsOptions {}
+
+type QuanticSmartSnippetSuggestionsE2ESearchFixtures = {
+  smartSnippetSuggestionsData: RelatedQuestionsData;
+  smartSnippetSuggestions: SmartSnippetSuggestionsObject;
+  search: SearchObjectWithSmartSnippet;
+  options: Partial<SmartSnippetSuggestionsOptions>;
+};
+
+type QuanticSmartSnippetSuggestionsE2EInsightFixtures =
+  QuanticSmartSnippetSuggestionsE2ESearchFixtures & {
+    insightSetup: InsightSetupObject;
+  };
+
+export const testSearch =
+  quanticBase.extend<QuanticSmartSnippetSuggestionsE2ESearchFixtures>({
+    smartSnippetSuggestionsData,
+    options: {},
+    search: async ({page}, use) => {
+      await use(new SearchObjectWithSmartSnippet(page, searchRequestRegex));
+    },
+    smartSnippetSuggestions: async (
+      {page, options, configuration, search, smartSnippetSuggestionsData: data},
+      use
+    ) => {
+      const smartSnippetSuggestionsObject = new SmartSnippetSuggestionsObject(
+        page
+      );
+
+      await page.goto(pageUrl);
+      await search.mockSearchWithSmartSnippetSuggestionsResponse(data);
+
+      configuration.configure(options);
+      await search.waitForSearchResponse();
+      await use(smartSnippetSuggestionsObject);
+    },
+  });
+
+export const testInsight =
+  quanticBase.extend<QuanticSmartSnippetSuggestionsE2EInsightFixtures>({
+    smartSnippetSuggestionsData,
+    options: {},
+    search: async ({page}, use) => {
+      await use(
+        new SearchObjectWithSmartSnippet(page, insightSearchRequestRegex)
+      );
+    },
+    insightSetup: async ({page}, use) => {
+      await use(new InsightSetupObject(page));
+    },
+    smartSnippetSuggestions: async (
+      {
+        page,
+        options,
+        search,
+        configuration,
+        insightSetup,
+        smartSnippetSuggestionsData: data,
+      },
+      use
+    ) => {
+      const smartSnippetSuggestionsObject = new SmartSnippetSuggestionsObject(
+        page
+      );
+
+      await page.goto(pageUrl);
+      await search.mockSearchWithSmartSnippetSuggestionsResponse(data);
+
+      configuration.configure({...options, useCase: useCaseEnum.insight});
+      await insightSetup.waitForInsightInterfaceInitialization();
+      await search.performSearch();
+      await search.waitForSearchResponse();
+      await use(smartSnippetSuggestionsObject);
+    },
+  });
+
+export {expect} from '@playwright/test';