@salesforcedevs/dx-components 1.40.11 → 1.42.0

package/src/modules/dx/sidebarSearch/sidebarSearch.ts

@@ -1,75 +1,68 @@
 import { LightningElement, api } from "lwc";
 import debounce from "debounce";
+import { track as trackGTM } from "dxUtils/analytics";
 import {
-    Result,
-    ResultList,
-    Unsubscribe,
-    ResultsPerPage,
-    SearchBox,
-    buildInteractiveResult,
-    buildResultList,
-    buildResultsPerPage,
-    buildSearchBox,
-    loadAdvancedSearchQueryActions,
-    SearchEngine,
-    SearchAppState,
-    loadQueryActions
-} from "@coveo/headless";
-import { buildSearchEngine, getSidebarSearchParams } from "dxUtils/coveo";
+    type OpenSearchCacheItem,
+    type OpenSearchResultItem,
+    fetchSearch,
+    resultHref,
+    getBaseUrlPath,
+    isCurrentLocation,
+    getStoredSearch,
+    isCacheStale,
+    setStoredSearch
+} from "dxUtils/openSearch";
+import { createSearchRegExp } from "dxUtils/regexps";
 import { RecentSearches } from "dxUtils/recentSearches";
-import { toJson } from "dxUtils/normalizers";
 import {
+    type HighlightedSections,
     Option,
     PopoverRequestCloseType,
     SidebarSearchResult
 } from "typings/custom";
 
-const RESULT_CLICK_LOCAL_STORAGE_KEY = "dx-sidebar-search-result-click";
-export const SESSION_KEY = "dx-sidebar-search-state";
-
-const DEFAULT_RESULT_COUNT = 20;
 const SEARCH_DEBOUNCE_DELAY = 1200;
 
-const UserRecentSearches = new RecentSearches();
-
-const normalizeCoveoAdvancedQueryValue = (version: string): string =>
-    version?.split(".").join("\\.");
-
-export default class SidebarSearch extends LightningElement {
-    @api coveoOrganizationId!: string;
-    @api coveoPublicAccessToken!: string;
-    @api coveoSearchHub!: string;
-    @api
-    get coveoAdvancedQueryConfig(): { [key: string]: any } {
-        return this._coveoAdvancedQueryConfig;
+/**
+ * Find all matches of the search query in text and return ranges for highlighting.
+ * Uses the same regex as the full-doc highlighter (createSearchRegExp) so sidebar
+ * and doc highlight the same phrases (including spaces between words).
+ */
+function getHighlightRanges(
+    text: string,
+    searchQuery: string
+): HighlightedSections {
+    if (!text || !searchQuery.trim()) {
+        return [];
     }
-    set coveoAdvancedQueryConfig(value) {
-        const jsonValue = toJson(value);
-        const hasChanged =
-            this._coveoAdvancedQueryConfig &&
-            Object.entries(jsonValue).some(
-                ([key, val]: [string, any]) =>
-                    this._coveoAdvancedQueryConfig[key] !== val
-            );
-        this._coveoAdvancedQueryConfig = jsonValue;
+    const re = createSearchRegExp(searchQuery.trim());
+    const ranges: HighlightedSections = [];
+    let match: RegExpExecArray | null;
+    while ((match = re.exec(text)) !== null) {
+        ranges.push({ offset: match.index, length: match[0].length });
+    }
+    return ranges;
+}
 
-        if (hasChanged && this.engine && this.value !== "") {
-            this.dispatchOnLoading(true);
-        }
+const UserRecentSearches = new RecentSearches();
 
-        if (hasChanged && this.engine) {
-            // set advanced filters needs access to the latest coveoAdvancedQueryConfig
-            this.setAdvancedFilters(this.engine);
-            this.submitSearch(true);
-        }
-    }
+function applySelectedAndSelect(
+    items: OpenSearchCacheItem[]
+): SidebarSearchResult[] {
+    return items.map((item) => ({
+        ...item,
+        selected: isCurrentLocation(item.href),
+        select: () => {}
+    }));
+}
 
+const getSearchQueryParam = (): string =>
+    new URLSearchParams(window.location.search).get("q") ?? "";
+
+export default class SidebarSearch extends LightningElement {
     @api
     public fetchMoreResults() {
-        if (this.resultList?.state?.moreResultsAvailable) {
-            this.fetchingMoreResults = true;
-            this.resultList.fetchMoreResults();
-        }
+        // OpenSearch API does not expose pagination in the same way; no-op
     }
 
     @api
@@ -85,313 +78,150 @@ export default class SidebarSearch extends LightningElement {
         this.dropdownRequestedOpen = value;
     }
 
-    private _coveoAdvancedQueryConfig!: { [key: string]: any };
     private dropdownRequestedOpen: boolean = false;
     private recentSearches: Option[] = [];
-    private unsubscribeFromResultList: Unsubscribe = () => {};
-    private resultList: ResultList | null = null;
-    private resultsPerPage: ResultsPerPage | null = null;
-    private preloadedState?: SearchAppState;
-    private searchBox: SearchBox | null = null;
-    private value?: string = "";
-    private engine: SearchEngine | null = null;
-    private fetchingMoreResults: boolean = false;
+    private value: string = "";
     private didRender = false;
-
-    private get hasCorrectCoveoConfig(): boolean {
-        const coveoConfigurations = [
-            this.coveoOrganizationId,
-            this.coveoPublicAccessToken,
-            this.coveoSearchHub,
-            this.coveoAdvancedQueryConfig
-        ];
-
-        return coveoConfigurations.every(
-            (val) =>
-                !!val && (typeof val === "string" || typeof val === "object")
-        );
-    }
+    private openSearchInitialized: boolean = false;
+    private didTrackThisSearch: boolean = false;
+    /** Bumped for every search and on clear; only the latest request may update state. */
+    private searchRequestId = 0;
 
     private get isDropdownOpen() {
         return (
             this.dropdownRequestedOpen &&
-            this.recentSearches &&
-            this.recentSearches.length > 0 &&
+            this.recentSearches?.length > 0 &&
             !this.value
         );
     }
 
     constructor() {
         super();
-
         this.updateRecentSearches();
-        this.value = getSidebarSearchParams() || "";
-    }
-
-    disconnectedCallback() {
-        this.unsubscribeFromResultList();
+        this.value = getSearchQueryParam();
     }
 
     renderedCallback() {
-        // in prod some of the critical coveo configuration attributes seem to arrive later
-        // so I needed to put this coveo startup flow here where we can wait for them to arrive
-
-        if (this.hasCorrectCoveoConfig && !this.engine) {
-            this.initializeUserSession();
-            this.initializeCoveo();
-        } else if (!this.hasCorrectCoveoConfig) {
-            console.error(
-                "Incorrect coveo search configuration provided. All coveo configuration attributes must be defined.",
-                {
-                    coveoOrganizationId: this.coveoOrganizationId,
-                    coveoPublicAccessToken: this.coveoPublicAccessToken,
-                    coveoSearchHub: this.coveoSearchHub,
-                    coveoAdvancedQueryConfig: this.coveoAdvancedQueryConfig
+        if (!this.openSearchInitialized) {
+            this.openSearchInitialized = true;
+            if (this.value) {
+                const baseUrlPath = getBaseUrlPath();
+                const cached = getStoredSearch(baseUrlPath);
+                const queryTrimmed = this.value.trim();
+                if (
+                    cached?.query === queryTrimmed &&
+                    Array.isArray(cached.results) &&
+                    !isCacheStale(cached)
+                ) {
+                    if (!this.didRender) {
+                        this.dispatchHighlightedTermChange();
+                    }
+                    const results = applySelectedAndSelect(cached.results);
+                    this.dispatchChange(results);
+                    this.dispatchOnLoading(false);
+                } else {
+                    if (!this.didRender) {
+                        this.dispatchHighlightedTermChange();
+                    }
+                    this.dispatchOnLoading(true);
+                    this.fetchOpenSearch();
                 }
-            );
+            } else {
+                // No URL query: restore search bar and results from localStorage for this path
+                const baseUrlPath = getBaseUrlPath();
+                const cached = getStoredSearch(baseUrlPath);
+                if (cached?.query && !isCacheStale(cached)) {
+                    this.value = cached.query;
+                    const results = applySelectedAndSelect(
+                        cached.results ?? []
+                    );
+                    this.dispatchChange(results);
+                    this.dispatchHighlightedTermChange();
+                }
+                this.dispatchOnLoading(false);
+            }
         }
-
-        // If this is the first render and there is a search value, trigger
-        // term highlighting
         if (!this.didRender && this.value) {
             this.dispatchHighlightedTermChange();
         }
-
         this.didRender = true;
     }
 
-    private initializeUserSession() {
-        const stringified = window.sessionStorage.getItem(SESSION_KEY);
-
-        if (!stringified) {
-            return;
-        }
+    private normalizeOpenSearchResult = (
+        item: OpenSearchResultItem,
+        index: number
+    ): SidebarSearchResult => {
+        const href = resultHref(item);
+        const title = item.title ?? "";
+        const excerpt = item.matchedText ?? "";
+        const searchQuery = this.value.trim();
+        return {
+            title,
+            titleHighlights: getHighlightRanges(title, searchQuery),
+            excerpt,
+            excerptHighlights: getHighlightRanges(excerpt, searchQuery),
+            // Several hits can share a page URL, so the index keeps keys unique.
+            uniqueId: `${index}:${href}`,
+            href,
+            selected: isCurrentLocation(href),
+            select: () => {}
+        };
+    };
 
+    private async fetchOpenSearch(): Promise<void> {
+        const requestId = ++this.searchRequestId;
+        const query = this.value.trim();
         try {
-            const json = JSON.parse(stringified);
-
-            const hasSameConfig = Object.entries(
-                json.coveoAdvancedQueryConfig
-            ).every(
-                ([key, value]: [string, any]) =>
-                    this.coveoAdvancedQueryConfig[key] === value
-            );
-            const hasSameQuery = json?.state?.query?.q === this.value;
-
-            if (hasSameConfig && hasSameQuery) {
-                this.preloadedState = json?.state;
-            } else {
-                window.sessionStorage.removeItem(SESSION_KEY);
+            const rawResults = await fetchSearch(query);
+            if (requestId !== this.searchRequestId) {
+                return;
             }
-        } catch (e) {
-            console.error(e);
-            window.sessionStorage.removeItem(SESSION_KEY);
-        }
-    }
-
-    private initializeCoveo = () => {
-        try {
-            this.engine = buildSearchEngine({
-                organizationId: this.coveoOrganizationId,
-                publicAccessToken: this.coveoPublicAccessToken,
-                searchHub: this.coveoSearchHub,
-                preloadedState: this.preloadedState
+            const results: SidebarSearchResult[] = rawResults.map(
+                this.normalizeOpenSearchResult
+            );
+            this.dispatchChange(results);
+            this.trackSearchResultsOnce(query, results.length);
+            const cacheItems: OpenSearchCacheItem[] = results.map((r) => ({
+                title: r.title,
+                titleHighlights: r.titleHighlights,
+                excerpt: r.excerpt,
+                excerptHighlights: r.excerptHighlights,
+                uniqueId: r.uniqueId,
+                href: r.href
+            }));
+            setStoredSearch(getBaseUrlPath(), {
+                query,
+                results: cacheItems
             });
-        } catch (ex) {
-            console.error(`Coveo engine failed to initialize (${ex})`);
-        }
-
-        if (!this.engine) {
-            console.error("Coveo engine failed to initialize!");
-            return;
-        }
-
-        if (this.preloadedState) {
-            const actions = loadQueryActions(this.engine);
-            this.engine.dispatch(actions.updateQuery({ q: this.value || "" }));
-        }
-
-        this.resultList = buildResultList(this.engine, {
-            options: { fieldsToInclude: ["sfhtml_url__c"] }
-        });
-
-        this.resultsPerPage = buildResultsPerPage(this.engine, {
-            initialState: {
-                numberOfResults: DEFAULT_RESULT_COUNT
+        } catch (err) {
+            if (requestId !== this.searchRequestId) {
+                return;
             }
-        });
-
-        this.searchBox = buildSearchBox(this.engine, {
-            options: { numberOfSuggestions: 3 }
-        });
-
-        this.setAdvancedFilters(this.engine);
-
-        this.unsubscribeFromResultList = this.resultList?.subscribe(
-            this.onResultListChange
-        );
-
-        if (this.value) {
-            this.dispatchHighlightedTermChange();
+            console.error("OpenSearch Search request failed", err);
+            this.dispatchChange([]);
         }
-
-        if (!this.preloadedState) {
-            if (this.value) {
-                this.submitSearch();
-            } else {
-                this.dispatchOnLoading(false);
-            }
-        }
-
-        this.syncAnalytics();
-    };
-
-    private syncAnalytics = () => {
-        const storedResult = window.localStorage.getItem(
-            RESULT_CLICK_LOCAL_STORAGE_KEY
-        );
-        if (storedResult) {
-            const interactiveResult = buildInteractiveResult(this.engine!, {
-                options: { result: JSON.parse(storedResult) }
-            });
-            interactiveResult.cancelPendingSelect();
-            interactiveResult.select();
-            window.localStorage.removeItem(RESULT_CLICK_LOCAL_STORAGE_KEY);
-        }
-    };
-
-    private onResultListChange = () => {
-        if (!this.resultList) {
-            return;
+        if (requestId === this.searchRequestId) {
+            this.dispatchOnLoading(false);
         }
+    }
 
-        const { isLoading, firstSearchExecuted, results } =
-            this.resultList.state;
-
-        if ((!firstSearchExecuted && !isLoading) || !this.value) {
-            // coveo search is firing off some unwanted payloads on startup
+    private trackSearchResultsOnce(term: string, resultCount: number): void {
+        if (this.didTrackThisSearch || !term) {
             return;
         }
-
-        if (!isLoading) {
-            this.dispatchOnChangeEvent(results);
-        }
-
-        if (!this.fetchingMoreResults) {
-            this.dispatchOnLoading(isLoading);
-        }
-
-        if (!isLoading && this.fetchingMoreResults) {
-            this.fetchingMoreResults = false;
-        }
-    };
-
-    private setAdvancedFilters(engine: SearchEngine) {
-        const aq = Object.entries(this.coveoAdvancedQueryConfig).reduce(
-            (result, [key, value]) =>
-                `${result}(@${key}=="${normalizeCoveoAdvancedQueryValue(
-                    value
-                )}")`,
-            ""
-        );
-
-        const registerSearchQueryAction = loadAdvancedSearchQueryActions(
-            engine
-        ).registerAdvancedSearchQueries({
-            aq: aq
+        this.didTrackThisSearch = true;
+        trackGTM(this.template.host, "custEv_scopedSearch", {
+            search_term: term,
+            search_category: "",
+            search_type: "site search",
+            search_result_count: resultCount
         });
-
-        engine.dispatch(registerSearchQueryAction);
     }
 
-    private normalizeCoveoResult = (result: Result): SidebarSearchResult => {
-        const {
-            clickUri,
-            excerpt,
-            excerptHighlights,
-            raw: { sfhtml_url__c },
-            title,
-            titleHighlights,
-            uniqueId
-        } = result;
-
-        // discussion about this normalization here: https://salesforce-internal.slack.com/archives/C020S6784JX/p1639506238376600
-
-        let pathname, queryParam;
-        if (sfhtml_url__c) {
-            pathname = `/docs/${sfhtml_url__c}`;
-        } else {
-            const isNestedGuide = clickUri.includes("/guide/");
-            const url = new URL(clickUri);
-            const extension =
-                isNestedGuide && !url.pathname?.endsWith(".html")
-                    ? ".html"
-                    : "";
-            pathname = `${url.pathname}${extension}`;
-            queryParam = url.search;
-        }
-
-        let href;
-        let isSelected = false;
-        const isReferenceUrl = clickUri.includes("/references/");
-        if (isReferenceUrl) {
-            if (queryParam) {
-                href = `${pathname}${queryParam}&q=${this.value}`;
-            } else {
-                href = `${pathname}?q=${this.value}`;
-            }
-
-            //NOTE: This is specific to references related comparison
-            const resultHrefWithMetaQuery = `${pathname}${queryParam}`;
-
-            const urlParams = new URLSearchParams(window.location.search);
-            const metaQueryParam = urlParams.get("meta");
-
-            let currentUrlPathWithQuery = window.location.pathname;
-            if (metaQueryParam) {
-                currentUrlPathWithQuery = `${currentUrlPathWithQuery}?meta=${metaQueryParam}`;
-            }
-
-            isSelected = resultHrefWithMetaQuery === currentUrlPathWithQuery;
-        } else {
-            href = `${pathname}?q=${this.value}`;
-            isSelected = pathname === window.location.pathname;
-        }
-
-        return {
-            title,
-            titleHighlights,
-            excerpt,
-            excerptHighlights,
-            uniqueId,
-            href,
-            selected: isSelected,
-            select: () =>
-                window.localStorage.setItem(
-                    RESULT_CLICK_LOCAL_STORAGE_KEY,
-                    JSON.stringify(result)
-                )
-        };
-    };
-
-    private updateSessionStorage() {
-        window.sessionStorage.setItem(
-            SESSION_KEY,
-            JSON.stringify({
-                coveoAdvancedQueryConfig: this.coveoAdvancedQueryConfig,
-                state: this.engine?.state
-            })
-        );
-    }
-
-    private dispatchOnChangeEvent(results: Result[]) {
-        this.updateSessionStorage();
+    private dispatchChange(results: SidebarSearchResult[]) {
         this.dispatchEvent(
             new CustomEvent("change", {
-                detail: {
-                    results: results.map(this.normalizeCoveoResult),
-                    value: this.value
-                }
+                detail: { results, value: this.value }
             })
         );
     }
@@ -427,24 +257,19 @@ export default class SidebarSearch extends LightningElement {
     }
 
     private submitSearch = debounce((isSyncingSearchValue = false) => {
-        if (this.searchBox) {
-            UserRecentSearches.add(this.value);
-            this.updateRecentSearches();
-
-            // When `isSyncingSearchValue` is true, we are submitting in a case
-            // where the search box is already synced correctly.
-            if (!isSyncingSearchValue) {
-                this.dispatchSidebarSearchChange(this.value);
-            }
-
-            this.searchBox.updateText(this.value || "");
-            this.searchBox.submit();
+        UserRecentSearches.add(this.value);
+        this.updateRecentSearches();
+        if (!isSyncingSearchValue) {
+            this.dispatchSidebarSearchChange(this.value);
         }
+        this.fetchOpenSearch();
     }, SEARCH_DEBOUNCE_DELAY);
 
     private onClickRecentSearch(e: CustomEvent) {
+        this.searchRequestId++;
         this.value = e.detail;
         this.dispatchSidebarSearchChange(this.value);
+        this.dispatchOnLoading(true);
         this.submitSearch(true);
     }
 
@@ -461,7 +286,6 @@ export default class SidebarSearch extends LightningElement {
 
     private onInputChange(e: CustomEvent) {
         this.value = e.detail;
-
         this.handleValueChange(false);
         this.dispatchHighlightedTermChange();
     }
@@ -475,19 +299,16 @@ export default class SidebarSearch extends LightningElement {
     }
 
     private handleValueChange(isSyncingSearchValue = false) {
+        this.searchRequestId++;
         if (this.value) {
+            this.didTrackThisSearch = false;
             this.dispatchOnLoading(true);
-            if (this.searchBox) {
-                this.submitSearch(isSyncingSearchValue);
-            }
+            this.submitSearch(isSyncingSearchValue);
         } else {
-            // coveo's reaction to an empty value triggers a return of results
-            // bootlegging our own ux here`
             this.dispatchOnLoading(false);
-            this.dispatchOnChangeEvent([]);
-            // Empty search values are not submitted for search, so we need to manually
-            // trigger a search change on our own here
+            this.dispatchChange([]);
             this.dispatchSidebarSearchChange(this.value);
+            setStoredSearch(getBaseUrlPath(), { query: "", results: [] });
         }
     }
 }