coveo.analytics 2.30.56 → 2.32.0

package/src/formatting/format-array-for-coveo-custom-data.ts

@@ -1,31 +1,31 @@
 function filterConsecutiveRepeatedValues(rawData: string[]) {
-    let prev = '';
-    return rawData.filter((value) => {
-        const isDifferent = value !== prev;
-        prev = value;
-        return isDifferent;
-    });
+  let prev = '';
+  return rawData.filter((value) => {
+    const isDifferent = value !== prev;
+    prev = value;
+    return isDifferent;
+  });
 }
 
 function removeSemicolons(rawData: string[]) {
-    return rawData.map((value) => {
-        return value.replace(/;/g, '');
-    });
+  return rawData.map((value) => {
+    return value.replace(/;/g, '');
+  });
 }
 
 function getDataString(data: string[]): string {
-    const ANALYTICS_LENGTH_LIMIT = 256;
+  const ANALYTICS_LENGTH_LIMIT = 256;
 
-    const formattedData = data.join(';');
-    if (formattedData.length <= ANALYTICS_LENGTH_LIMIT) {
-        return formattedData;
-    }
-    return getDataString(data.slice(1));
+  const formattedData = data.join(';');
+  if (formattedData.length <= ANALYTICS_LENGTH_LIMIT) {
+    return formattedData;
+  }
+  return getDataString(data.slice(1));
 }
 
 export const formatArrayForCoveoCustomData = (rawData: string[]): string => {
-    const dataWithoutSemicolons = removeSemicolons(rawData);
-    const dataWithoutRepeatedValues = filterConsecutiveRepeatedValues(dataWithoutSemicolons);
+  const dataWithoutSemicolons = removeSemicolons(rawData);
+  const dataWithoutRepeatedValues = filterConsecutiveRepeatedValues(dataWithoutSemicolons);
 
-    return getDataString(dataWithoutRepeatedValues);
+  return getDataString(dataWithoutRepeatedValues);
 };

package/src/formatting/format-omnibox-metadata.ts

@@ -1,17 +1,21 @@
 import {OmniboxSuggestionsMetadata} from '../searchPage/searchPageEvents';
 import {formatArrayForCoveoCustomData} from './format-array-for-coveo-custom-data';
 
-export function formatOmniboxMetadata(meta: OmniboxSuggestionsMetadata): OmniboxSuggestionsMetadata {
-    const partialQueries =
-        typeof meta.partialQueries === 'string'
-            ? meta.partialQueries
-            : formatArrayForCoveoCustomData(meta.partialQueries);
-    const suggestions =
-        typeof meta.suggestions === 'string' ? meta.suggestions : formatArrayForCoveoCustomData(meta.suggestions);
+export function formatOmniboxMetadata(
+  meta: OmniboxSuggestionsMetadata
+): OmniboxSuggestionsMetadata {
+  const partialQueries =
+    typeof meta.partialQueries === 'string'
+      ? meta.partialQueries
+      : formatArrayForCoveoCustomData(meta.partialQueries);
+  const suggestions =
+    typeof meta.suggestions === 'string'
+      ? meta.suggestions
+      : formatArrayForCoveoCustomData(meta.suggestions);
 
-    return {
-        ...meta,
-        partialQueries,
-        suggestions,
-    };
+  return {
+    ...meta,
+    partialQueries,
+    suggestions,
+  };
 }

package/src/history.spec.ts

@@ -1,201 +1,203 @@
+import {vi} from 'vitest';
+import type {Mocked} from 'vitest';
 import * as history from './history';
 import {MAX_NUMBER_OF_HISTORY_ELEMENTS} from './history';
 import {WebStorage} from './storage';
 
 describe('history', () => {
-    let storageMock: jest.Mocked<WebStorage>;
-    let historyStore: history.HistoryStore;
-    let data: history.HistoryElement;
-
-    beforeEach(() => {
-        let storageData: any;
-        storageMock = {
-            getItem: jest.fn((key) => storageData),
-            setItem: jest.fn((key, data) => {
-                storageData = data;
-            }),
-            removeItem: jest.fn(),
-        };
-        historyStore = new history.HistoryStore(storageMock);
-        data = {
-            name: 'name',
-            value: 'value',
-            time: new Date().toISOString(),
-        };
-    });
-
-    it('should return the same an element after adding it to the history', () => {
-        historyStore.addElement(data);
-
-        expect(storageMock.setItem).toHaveBeenCalledTimes(1);
-        const [setKey, setData] = storageMock.setItem.mock.calls[0];
-
-        expect(setKey).toBe(history.STORE_KEY);
-        expect(setData).toMatch(/"value":"value"/);
-        expect(setData).toMatch(/"time"/);
-        expect(setData).toMatch(/"internalTime"/);
-    });
-
-    it('should return the same an element after adding it to the history', async () => {
-        await historyStore.addElementAsync(data);
-
-        expect(storageMock.setItem).toHaveBeenCalledTimes(1);
-        const [setKey, setData] = storageMock.setItem.mock.calls[0];
-
-        expect(setKey).toBe(history.STORE_KEY);
-        expect(setData).toMatch(/"value":"value"/);
-        expect(setData).toMatch(/"time"/);
-        expect(setData).toMatch(/"internalTime"/);
-    });
-
-    it('should trim query over > 75 char', async () => {
-        data.value = '';
-        let newValue = '';
-        for (let i = 0; i < 100; i++) {
-            newValue += i.toString();
-        }
-        data.name = 'Query';
-        data.value = newValue;
-
-        await historyStore.addElementAsync(data);
-
-        expect(storageMock.setItem).toHaveBeenCalledTimes(1);
-        const [setKey, setData] = storageMock.setItem.mock.calls[0];
-
-        expect(setKey).toBe(history.STORE_KEY);
-        expect(setData).toMatch(/"value":"01234[0-9]{70}"/);
-    });
-
-    it("should not trim elements over 75 char if it's not a query", async () => {
-        data.value = '';
-        let newValue = '';
-        for (let i = 0; i < 100; i++) {
-            newValue += i.toString();
-        }
-        data.name = 'Not A Query';
-        data.value = newValue;
-
-        await historyStore.addElementAsync(data);
-
-        expect(storageMock.setItem).toHaveBeenCalledTimes(1);
-        const [setKey, setData] = storageMock.setItem.mock.calls[0];
-
-        expect(setKey).toBe(history.STORE_KEY);
-        expect(setData).toMatch(/"value":"01234[0-9]{185}"/);
-    });
-
-    it('should not keep more then MAX_ELEMENTS', async () => {
-        for (let i = 0; i < MAX_NUMBER_OF_HISTORY_ELEMENTS + 5; i++) {
-            data.value = i.toString();
-            await historyStore.addElementAsync(data);
-        }
-        const history = await historyStore.getHistoryAsync();
-        expect(history.length).toBe(MAX_NUMBER_OF_HISTORY_ELEMENTS);
-    });
-
-    it('should be able to remove all internalTime', () => {
-        const historyElements: history.HistoryElement[] = [];
-        for (let i = 0; i < 5; i++) {
-            historyElements.push({
-                name: 'name' + i,
-                value: 'value' + i,
-                time: new Date().toISOString(),
-                internalTime: new Date().getTime(),
-            });
-        }
-
-        for (let elem of historyElements) {
-            expect(elem).toHaveProperty('internalTime');
-        }
-
-        const stripedHistoryElements = historyStore['stripInternalTime'](historyElements);
-
-        for (let elem of stripedHistoryElements) {
-            expect(elem).not.toHaveProperty('internalTime');
-        }
-    });
-
-    it('should strip empty query values when calling getHistoryAsync', async () => {
-        data.name = 'Query';
-        data.value = '';
-        const historyElements: history.HistoryElement[] = [data];
-        historyStore.setHistory(historyElements);
-
-        const history = await historyStore.getHistoryAsync();
-        expect(history[0].value).toBeUndefined();
-    });
-
-    it('should strip empty query values when calling getHistory', () => {
-        data.name = 'Query';
-        data.value = '';
-        const historyElements: history.HistoryElement[] = [data];
-        historyStore.setHistory(historyElements);
-
-        const history = historyStore.getHistory();
-        expect(history[0].value).toBeUndefined();
-    });
-
-    it('should strip empty query from new element (addElement)', () => {
-        data.name = 'Query';
-        data.value = '';
-        historyStore.addElement(data);
-
-        const [_, setData] = storageMock.setItem.mock.calls[0];
-        expect(setData).not.toMatch(/"value"/);
-    });
-
-    it('should strip empty query from new element (addElementAsync)', async () => {
-        data.name = 'Query';
-        data.value = '';
-        await historyStore.addElementAsync(data);
-
-        const [_, setData] = storageMock.setItem.mock.calls[0];
-        expect(setData).not.toMatch(/"value"/);
-    });
-
-    it('should remove item when cleared', () => {
-        historyStore.clear();
-
-        expect(storageMock.removeItem).toHaveBeenCalledWith(history.STORE_KEY);
-    });
-
-    it('should be able to set the history', () => {
-        const historyElements: history.HistoryElement[] = [data];
-
-        historyStore.setHistory(historyElements);
-
-        expect(storageMock.setItem).toHaveBeenCalledWith(
-            history.STORE_KEY,
-            expect.stringContaining(JSON.stringify(historyElements)),
-        );
-    });
-
-    it('should reject consecutive duplicate values', async () => {
-        await historyStore.addElementAsync(data);
-        await historyStore.addElementAsync(data);
-
-        expect(storageMock.setItem).toHaveBeenCalledTimes(1);
-    });
-
-    it('should accept consecutive values which are not duplicates', async () => {
-        await historyStore.addElementAsync(data);
-        data.value = 'something else';
-        await historyStore.addElementAsync(data);
-
-        expect(storageMock.setItem).toHaveBeenCalledTimes(2);
-    });
-
-    it('should not throw when the content of localStorage is not an array', async () => {
-        storageMock.setItem(history.STORE_KEY, '{"foo":"bar"}');
-        let ex: any;
-        try {
-            const mostRecentElement = await historyStore.getMostRecentElement();
-            expect(mostRecentElement).toBeNull();
-            const localHistory = await historyStore.getHistoryAsync();
-            expect(localHistory).toStrictEqual([]);
-        } catch (err) {
-            ex = err;
-        }
-        expect(ex).toBeUndefined();
-    });
+  let storageMock: Mocked<WebStorage>;
+  let historyStore: history.HistoryStore;
+  let data: history.HistoryElement;
+
+  beforeEach(() => {
+    let storageData: any;
+    storageMock = {
+      getItem: vi.fn((key) => storageData),
+      setItem: vi.fn((key, data) => {
+        storageData = data;
+      }),
+      removeItem: vi.fn(),
+    };
+    historyStore = new history.HistoryStore(storageMock);
+    data = {
+      name: 'name',
+      value: 'value',
+      time: new Date().toISOString(),
+    };
+  });
+
+  it('should return the same an element after adding it to the history', () => {
+    historyStore.addElement(data);
+
+    expect(storageMock.setItem).toHaveBeenCalledTimes(1);
+    const [setKey, setData] = storageMock.setItem.mock.calls[0];
+
+    expect(setKey).toBe(history.STORE_KEY);
+    expect(setData).toMatch(/"value":"value"/);
+    expect(setData).toMatch(/"time"/);
+    expect(setData).toMatch(/"internalTime"/);
+  });
+
+  it('should return the same an element after adding it to the history', async () => {
+    await historyStore.addElementAsync(data);
+
+    expect(storageMock.setItem).toHaveBeenCalledTimes(1);
+    const [setKey, setData] = storageMock.setItem.mock.calls[0];
+
+    expect(setKey).toBe(history.STORE_KEY);
+    expect(setData).toMatch(/"value":"value"/);
+    expect(setData).toMatch(/"time"/);
+    expect(setData).toMatch(/"internalTime"/);
+  });
+
+  it('should trim query over > 75 char', async () => {
+    data.value = '';
+    let newValue = '';
+    for (let i = 0; i < 100; i++) {
+      newValue += i.toString();
+    }
+    data.name = 'Query';
+    data.value = newValue;
+
+    await historyStore.addElementAsync(data);
+
+    expect(storageMock.setItem).toHaveBeenCalledTimes(1);
+    const [setKey, setData] = storageMock.setItem.mock.calls[0];
+
+    expect(setKey).toBe(history.STORE_KEY);
+    expect(setData).toMatch(/"value":"01234[0-9]{70}"/);
+  });
+
+  it("should not trim elements over 75 char if it's not a query", async () => {
+    data.value = '';
+    let newValue = '';
+    for (let i = 0; i < 100; i++) {
+      newValue += i.toString();
+    }
+    data.name = 'Not A Query';
+    data.value = newValue;
+
+    await historyStore.addElementAsync(data);
+
+    expect(storageMock.setItem).toHaveBeenCalledTimes(1);
+    const [setKey, setData] = storageMock.setItem.mock.calls[0];
+
+    expect(setKey).toBe(history.STORE_KEY);
+    expect(setData).toMatch(/"value":"01234[0-9]{185}"/);
+  });
+
+  it('should not keep more then MAX_ELEMENTS', async () => {
+    for (let i = 0; i < MAX_NUMBER_OF_HISTORY_ELEMENTS + 5; i++) {
+      data.value = i.toString();
+      await historyStore.addElementAsync(data);
+    }
+    const history = await historyStore.getHistoryAsync();
+    expect(history.length).toBe(MAX_NUMBER_OF_HISTORY_ELEMENTS);
+  });
+
+  it('should be able to remove all internalTime', () => {
+    const historyElements: history.HistoryElement[] = [];
+    for (let i = 0; i < 5; i++) {
+      historyElements.push({
+        name: 'name' + i,
+        value: 'value' + i,
+        time: new Date().toISOString(),
+        internalTime: new Date().getTime(),
+      });
+    }
+
+    for (let elem of historyElements) {
+      expect(elem).toHaveProperty('internalTime');
+    }
+
+    const stripedHistoryElements = historyStore['stripInternalTime'](historyElements);
+
+    for (let elem of stripedHistoryElements) {
+      expect(elem).not.toHaveProperty('internalTime');
+    }
+  });
+
+  it('should strip empty query values when calling getHistoryAsync', async () => {
+    data.name = 'Query';
+    data.value = '';
+    const historyElements: history.HistoryElement[] = [data];
+    historyStore.setHistory(historyElements);
+
+    const history = await historyStore.getHistoryAsync();
+    expect(history[0].value).toBeUndefined();
+  });
+
+  it('should strip empty query values when calling getHistory', () => {
+    data.name = 'Query';
+    data.value = '';
+    const historyElements: history.HistoryElement[] = [data];
+    historyStore.setHistory(historyElements);
+
+    const history = historyStore.getHistory();
+    expect(history[0].value).toBeUndefined();
+  });
+
+  it('should strip empty query from new element (addElement)', () => {
+    data.name = 'Query';
+    data.value = '';
+    historyStore.addElement(data);
+
+    const [_, setData] = storageMock.setItem.mock.calls[0];
+    expect(setData).not.toMatch(/"value"/);
+  });
+
+  it('should strip empty query from new element (addElementAsync)', async () => {
+    data.name = 'Query';
+    data.value = '';
+    await historyStore.addElementAsync(data);
+
+    const [_, setData] = storageMock.setItem.mock.calls[0];
+    expect(setData).not.toMatch(/"value"/);
+  });
+
+  it('should remove item when cleared', () => {
+    historyStore.clear();
+
+    expect(storageMock.removeItem).toHaveBeenCalledWith(history.STORE_KEY);
+  });
+
+  it('should be able to set the history', () => {
+    const historyElements: history.HistoryElement[] = [data];
+
+    historyStore.setHistory(historyElements);
+
+    expect(storageMock.setItem).toHaveBeenCalledWith(
+      history.STORE_KEY,
+      expect.stringContaining(JSON.stringify(historyElements))
+    );
+  });
+
+  it('should reject consecutive duplicate values', async () => {
+    await historyStore.addElementAsync(data);
+    await historyStore.addElementAsync(data);
+
+    expect(storageMock.setItem).toHaveBeenCalledTimes(1);
+  });
+
+  it('should accept consecutive values which are not duplicates', async () => {
+    await historyStore.addElementAsync(data);
+    data.value = 'something else';
+    await historyStore.addElementAsync(data);
+
+    expect(storageMock.setItem).toHaveBeenCalledTimes(2);
+  });
+
+  it('should not throw when the content of localStorage is not an array', async () => {
+    storageMock.setItem(history.STORE_KEY, '{"foo":"bar"}');
+    let ex: any;
+    try {
+      const mostRecentElement = await historyStore.getMostRecentElement();
+      expect(mostRecentElement).toBeNull();
+      const localHistory = await historyStore.getHistoryAsync();
+      expect(localHistory).toStrictEqual([]);
+    } catch (err) {
+      ex = err;
+    }
+    expect(ex).toBeUndefined();
+  });
 });