coveo.analytics 2.30.27 → 2.30.36

package/src/client/utils.spec.ts

@@ -0,0 +1,113 @@
+import {truncateUrl} from './utils';
+
+describe('utils', () => {
+    describe('truncateUrl', () => {
+        // Note: to obtain a UTF-8 encoded escape sequence, run encodeUriComponent('<value>') in your browser console or NodeJS REPL
+        const URL_PLAIN = 'http://coveo.com/this/is/a/really/long/url/that/will/be/truncated?at=some&arbitrary=point';
+
+        it.each([[8], [16], [32], [64], [128]])(
+            `truncateUrl('${URL_PLAIN}', %d) truncates to exactly that length`,
+            (limit) => {
+                expect(truncateUrl(URL_PLAIN, limit)).toBe(URL_PLAIN.substring(0, limit));
+            }
+        );
+
+        /** Decoded: `'http://test/ ¿OKツ😅#fine'` */
+        const URL_WITH_ESCAPES = 'http://test/%20%C2%BFOK%E3%83%84%F0%9F%98%85#fine';
+        // Number of bytes in code-point:     <1>< 2  >  <   3   ><    4     >
+
+        it.each([[7], [22], [45], [46], [47], [48], [100]])(
+            `truncateUrl('${URL_WITH_ESCAPES}', %d) truncates to the exact limit outside of codepoints`,
+            (limit) => {
+                expect(truncateUrl(URL_WITH_ESCAPES, limit)).toBe(URL_WITH_ESCAPES.substring(0, limit));
+            }
+        );
+
+        it.each([
+            [12, 12],
+            [13, 12],
+            [14, 12],
+            [15, 15],
+        ])(
+            `truncateUrl('${URL_WITH_ESCAPES}', %d) does not break up single-byte codepoints`,
+            (limit, expectedLength) => {
+                expect(truncateUrl(URL_WITH_ESCAPES, limit)).toBe(URL_WITH_ESCAPES.substring(0, expectedLength));
+            }
+        );
+
+        it.each([
+            [15, 15],
+            [16, 15],
+            [17, 15],
+            [18, 15],
+            [19, 15],
+            [20, 15],
+            [21, 21],
+        ])(`truncateUrl('${URL_WITH_ESCAPES}', %d) does not break up two-byte codepoints`, (limit, expectedLength) => {
+            expect(truncateUrl(URL_WITH_ESCAPES, limit)).toBe(URL_WITH_ESCAPES.substring(0, expectedLength));
+        });
+
+        it.each([
+            [23, 23],
+            [24, 23],
+            [25, 23],
+            [26, 23],
+            [27, 23],
+            [28, 23],
+            [29, 23],
+            [30, 23],
+            [31, 23],
+            [32, 32],
+        ])(
+            `truncateUrl('${URL_WITH_ESCAPES}', %d) does not break up three-byte codepoints`,
+            (limit, expectedLength) => {
+                expect(truncateUrl(URL_WITH_ESCAPES, limit)).toBe(URL_WITH_ESCAPES.substring(0, expectedLength));
+            }
+        );
+
+        it.each([
+            [32, 32],
+            [33, 32],
+            [34, 32],
+            [35, 32],
+            [36, 32],
+            [37, 32],
+            [38, 32],
+            [39, 32],
+            [40, 32],
+            [41, 32],
+            [42, 32],
+            [43, 32],
+            [44, 44],
+        ])(`truncateUrl('${URL_WITH_ESCAPES}', %d) does not break up four-byte codepoints`, (limit, expectedLength) => {
+            expect(truncateUrl(URL_WITH_ESCAPES, limit)).toBe(URL_WITH_ESCAPES.substring(0, expectedLength));
+        });
+
+        const URL_WITH_INVALID_ESCAPES = 'http://test/%this%is%so%invalid';
+
+        it.each([
+            [12, 12],
+            [13, 12],
+            [14, 12],
+            [15, 15],
+            [16, 16],
+            [17, 17],
+            [18, 17],
+            [19, 17],
+            [20, 20],
+            [21, 20],
+            [22, 20],
+            [23, 23],
+            [24, 23],
+            [25, 23],
+            [26, 26],
+        ])(
+            `truncateUrl('${URL_WITH_INVALID_ESCAPES}', %d) only checks for percent with invalid escapes`,
+            (limit, expectedLength) => {
+                expect(truncateUrl(URL_WITH_INVALID_ESCAPES, limit)).toBe(
+                    URL_WITH_INVALID_ESCAPES.substring(0, expectedLength)
+                );
+            }
+        );
+    });
+});

package/src/client/utils.ts

@@ -15,3 +15,68 @@ export function isObject(o: any): boolean {
 export function coerceToNumber(input: any): any {
     return typeof input === 'string' && input != '' && !Number.isNaN(+input) ? +input : input;
 }
+
+/**
+ * Can be used to both check if the first bit is set (for any utf-8 multibyte part),
+ * and to detect "following bytes" (which start with `10xx_xxxx`)
+ */
+const UTF8_HIGH_BIT = 0b1000_0000;
+/** Header for a 2-byte code point: `110x_xxxx`. Can also be used as bit-mask to check for "following bytes". */
+const UTF8_HEADER_2 = 0b1100_0000;
+/** Header for a 3-byte code point: `1110_xxxx`. Can also be used as bit-mask to check for "header 2". */
+const UTF8_HEADER_3 = 0b1110_0000;
+/** Header for a 4-byte code point: `1111_0xxx`. Can also be used as bit-mask to check for "header 3". */
+const UTF8_HEADER_4 = 0b1111_0000;
+
+function utf8ByteCountFromFirstByte(firstByte: number): number {
+    if ((firstByte & 0b1111_1000) === UTF8_HEADER_4) {
+        return 4;
+    }
+    if ((firstByte & UTF8_HEADER_4) === UTF8_HEADER_3) {
+        return 3;
+    }
+    if ((firstByte & UTF8_HEADER_3) === UTF8_HEADER_2) {
+        return 2;
+    }
+    return 1;
+}
+
+/**
+ * Truncate a URL to an arbitrary length, taking care to not break inside a percent escape or UTF-8 multibyte sequence.
+ *
+ * @param input The input to truncate to the specified limit.
+ * @param limit The limit to apply; if negative, no truncation is applied.
+ * @returns The URL, possibly truncated to a length near limit (at most 11 characters less than limit).
+ */
+export function truncateUrl(input: string, limit: number): string {
+    if (limit < 0 || input.length <= limit) {
+        return input;
+    }
+    // A valid escape sequence is a percent followed by 2 hexadecimal characters; check if we split one up.
+    let end = input.indexOf('%', limit - 2);
+    if (end < 0 || end > limit) {
+        end = limit;
+    } else {
+        limit = end;
+    }
+    // Check that truncating at end won't break up an UTF-8 multibyte sequence half-way,
+    // by peeking backwards to find the first byte of an UTF-8 sequence (if present).
+    while (end > 2 && input.charAt(end - 3) == '%') {
+        const peekByte = Number.parseInt(input.substring(end - 2, end), 16);
+        // Note: if parsing fails, NaN gets coerced to 0 by the bitwise and.
+        if ((peekByte & UTF8_HIGH_BIT) != UTF8_HIGH_BIT) {
+            break;
+        }
+        end -= 3;
+        // Check if we reached the first byte by checking it is not a "follow byte": 10xx_xxxx.
+        if ((peekByte & UTF8_HEADER_2) != UTF8_HIGH_BIT) {
+            // If the full code point is there, keep it.
+            if (limit - end >= utf8ByteCountFromFirstByte(peekByte) * 3) {
+                end = limit;
+            }
+            // Otherwise, end is already set at the correct point to truncate at (the start of the multibyte sequence).
+            break;
+        }
+    }
+    return input.substring(0, end);
+}

package/src/insight/insightClient.spec.ts

@@ -653,6 +653,14 @@ describe('InsightClient', () => {
             expectMatchCustomEventPayload(InsightEvents.createArticle, exampleCreateArticleMetadata);
         });
 
+        it('should send proper payload for #logTriggerNotify', async () => {
+            const exampleTriggerNotifyMetadata = {
+                notifications: ['foo', 'bar'],
+            };
+            await client.logTriggerNotify(exampleTriggerNotifyMetadata);
+            expectMatchCustomEventPayload(SearchPageEvents.triggerNotify, exampleTriggerNotifyMetadata);
+        });
+
         it('should send proper payload for #generatedAnswerFeedbackSubmitV2', async () => {
             const exampleGeneratedAnswerMetadata = {
                 generativeQuestionAnsweringId: '123',
@@ -1488,6 +1496,18 @@ describe('InsightClient', () => {
             await client.logCreateArticle(exampleCreateArticleMetadata, baseCaseMetadata);
             expectMatchCustomEventPayload(InsightEvents.createArticle, expectedMetadata);
         });
+
+        it('should send proper payload for #logTriggerNotify', async () => {
+            const exampleTriggerNotifyMetadata = {
+                notifications: ['foo', 'bar'],
+            };
+            const expectedMetadata = {
+                ...exampleTriggerNotifyMetadata,
+                ...expectedBaseCaseMetadata,
+            };
+            await client.logTriggerNotify(exampleTriggerNotifyMetadata, baseCaseMetadata);
+            expectMatchCustomEventPayload(SearchPageEvents.triggerNotify, expectedMetadata);
+        });
     });
 
     it('should enable analytics tracking by default', () => {

package/src/insight/insightClient.ts

@@ -19,6 +19,7 @@ import {
     SmartSnippetFeedbackReason,
     SmartSnippetLinkMeta,
     SmartSnippetSuggestionMeta,
+    TriggerNotifyMetadata,
 } from '../searchPage/searchPageEvents';
 import {
     ExpandToFullUIMetadata,
@@ -687,6 +688,13 @@ export class CoveoInsightClient {
         );
     }
 
+    public logTriggerNotify(triggerNotifyMetadata: TriggerNotifyMetadata, metadata?: CaseMetadata) {
+        return this.logCustomEvent(
+            SearchPageEvents.triggerNotify,
+            metadata ? {...generateMetadataToSend(metadata, false), ...triggerNotifyMetadata} : triggerNotifyMetadata
+        );
+    }
+
     private async getBaseCustomEventRequest(metadata?: Record<string, any>) {
         return {
             ...(await this.getBaseEventRequest(metadata)),

package/src/searchPage/searchPageEvents.ts

@@ -539,41 +539,48 @@ export interface SmartSnippetDocumentIdentifier {
 
 export type PartialDocumentInformation = Omit<DocumentInformation, 'actionCause' | 'searchQueryUid'>;
 
-export interface GeneratedAnswerBaseMeta {
+interface AnswerGeneratedWithAnswerAPI {
+    answerAPIStreamId: string;
+    generativeQuestionAnsweringId?: never;
+}
+
+interface AnswerGeneratedWithSearchAPI {
+    answerAPIStreamId?: never;
     generativeQuestionAnsweringId: string;
 }
 
-export interface GeneratedAnswerStreamEndMeta extends GeneratedAnswerBaseMeta {
+export type GeneratedAnswerBaseMeta = AnswerGeneratedWithAnswerAPI | AnswerGeneratedWithSearchAPI;
+
+export type GeneratedAnswerStreamEndMeta = GeneratedAnswerBaseMeta & {
     answerGenerated: boolean;
     answerTextIsEmpty?: boolean;
-}
+};
 
-export interface GeneratedAnswerCitationMeta {
-    generativeQuestionAnsweringId: string;
+export type GeneratedAnswerCitationMeta = GeneratedAnswerBaseMeta & {
     permanentId: string;
     citationId: string;
-}
+};
 
 export type GeneratedAnswerFeedbackReason = 'irrelevant' | 'notAccurate' | 'outOfDate' | 'harmful' | 'other';
 
 export type GeneratedAnswerRephraseFormat = 'step' | 'bullet' | 'concise' | 'default';
 
-export interface GeneratedAnswerSourceHoverMeta extends GeneratedAnswerCitationMeta {
+export type GeneratedAnswerSourceHoverMeta = GeneratedAnswerCitationMeta & {
     citationHoverTimeMs: number;
-}
+};
 
-export interface GeneratedAnswerRephraseMeta extends GeneratedAnswerBaseMeta {
+export type GeneratedAnswerRephraseMeta = GeneratedAnswerBaseMeta & {
     rephraseFormat: GeneratedAnswerRephraseFormat;
-}
+};
 
-export interface GeneratedAnswerFeedbackMeta extends GeneratedAnswerBaseMeta {
+export type GeneratedAnswerFeedbackMeta = GeneratedAnswerBaseMeta & {
     reason: GeneratedAnswerFeedbackReason;
     details?: string;
-}
+};
 
 export type GeneratedAnswerFeedbackReasonOption = 'yes' | 'unknown' | 'no';
 
-export interface GeneratedAnswerFeedbackMetaV2 extends GeneratedAnswerBaseMeta {
+export type GeneratedAnswerFeedbackMetaV2 = GeneratedAnswerBaseMeta & {
     helpful: boolean;
     readable: GeneratedAnswerFeedbackReasonOption;
     documented: GeneratedAnswerFeedbackReasonOption;
@@ -581,4 +588,4 @@ export interface GeneratedAnswerFeedbackMetaV2 extends GeneratedAnswerBaseMeta {
     hallucinationFree: GeneratedAnswerFeedbackReasonOption;
     details?: string;
     documentUrl?: string;
-}
+};