@salesforcedevs/dx-components 0.16.2 → 0.18.1

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

@@ -0,0 +1,113 @@
+import { createElement } from "lwc";
+import SidebarSearch from "dx/sidebarSearch";
+import { createRenderComponent, renderLightningElement } from "utils/tests";
+import { coveoXMLDocsConfig } from "utils/coveo";
+import { mockQueryParameter, unmockQueryParameter } from "utils/jest";
+
+const TAG = "dx-sidebar-search";
+const render = createRenderComponent(TAG, SidebarSearch);
+
+const PROPS = coveoXMLDocsConfig;
+const QUERY = "test";
+
+describe(TAG, () => {
+    afterEach(unmockQueryParameter);
+
+    it("renders with the correct initial empty query", () => {
+        const element = render(PROPS);
+
+        const input = element.shadowRoot.querySelector("dx-input");
+
+        expect(input.value).toEqual("");
+
+        return expect(element).toBeAccessible();
+    });
+
+    it("renders with the correct initial query", () => {
+        mockQueryParameter(QUERY);
+
+        const element = render(PROPS);
+
+        const input = element.shadowRoot.querySelector("dx-input");
+
+        expect(input.value).toEqual(QUERY);
+
+        return expect(element).toBeAccessible();
+    });
+
+    describe("highlighting", () => {
+        afterEach(unmockQueryParameter);
+
+        it("triggers on initial render when a search value exists", () => {
+            mockQueryParameter(QUERY);
+            const element = createElement(TAG, { is: SidebarSearch });
+            const dispatchEventSpy = jest.spyOn(element, "dispatchEvent");
+            renderLightningElement(element, PROPS);
+            expect(dispatchEventSpy).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    type: "highlightedtermchange",
+                    detail: QUERY
+                })
+            );
+        });
+
+        it("does not trigger on initial render when a search value does not exist", () => {
+            const element = createElement(TAG, { is: SidebarSearch });
+            const dispatchEventSpy = jest.spyOn(element, "dispatchEvent");
+            renderLightningElement(element, PROPS);
+            expect(dispatchEventSpy).not.toHaveBeenCalledWith(
+                expect.objectContaining({ type: "highlightedtermchange" })
+            );
+        });
+
+        it("triggers on input change with non-empty value", () => {
+            const element = render(PROPS);
+            const dxInput = element.shadowRoot.querySelector("dx-input");
+            const dispatchEventSpy = jest.spyOn(element, "dispatchEvent");
+
+            dxInput.dispatchEvent(new CustomEvent("change", { detail: QUERY }));
+
+            expect(dispatchEventSpy).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    type: "highlightedtermchange",
+                    detail: QUERY
+                })
+            );
+        });
+
+        it("triggers on input change with empty value", () => {
+            const element = render(PROPS);
+            const dxInput = element.shadowRoot.querySelector("dx-input");
+            const dispatchEventSpy = jest.spyOn(element, "dispatchEvent");
+
+            dxInput.dispatchEvent(new CustomEvent("change", { detail: "" }));
+
+            expect(dispatchEventSpy).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    type: "highlightedtermchange",
+                    detail: ""
+                })
+            );
+        });
+    });
+});
+
+// git("correctly consumes a valid session storage object", () => {
+//     mockQueryParameter(mockPreloadedState.query.q);
+
+//     window.sessionStorage.setItem(
+//         SESSION_KEY,
+//         JSON.stringify(mockPreloadedState)
+//     );
+
+//     const mockOnChange = jest.fn();
+
+//     const element = render(PROPS);
+//     element.addEventListener("change", mockOnChange);
+
+//     return Promise.resolve().then(() => {
+//         expect(mockOnChange).toHaveBeenCalledTimes(1);
+
+//         expect(element).toBeAccessible();
+//     });
+// });

package/src/modules/dx/sidebarSearch/sidebarSearch.css

@@ -0,0 +1,3 @@
+.search-box {
+    --dx-c-input-width: 100%;
+}

package/src/modules/dx/sidebarSearch/sidebarSearch.html

@@ -0,0 +1,26 @@
+<template>
+    <dx-dropdown
+        aria-label="Recent Searches"
+        open={isDropdownOpen}
+        options={recentSearches}
+        onchange={onClickRecentSearch}
+        onrequestclose={onDropdownRequestClose}
+        full-width
+    >
+        <dx-input
+            class="search-box"
+            type="search"
+            placeholder="Search this list..."
+            role="search"
+            aria-label="Content Search"
+            icon-symbol="search"
+            size="small"
+            value={value}
+            onchange={onInputChange}
+            onfocus={onInputFocus}
+            onclear={onInputClear}
+            shortcut-key="j"
+            clearable
+        ></dx-input>
+    </dx-dropdown>
+</template>

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

@@ -0,0 +1,421 @@
+import { LightningElement, api } from "lwc";
+import debounce from "debounce";
+import {
+    Result,
+    ResultList,
+    Unsubscribe,
+    ResultsPerPage,
+    SearchBox,
+    buildResultList,
+    buildResultsPerPage,
+    buildSearchBox,
+    loadAdvancedSearchQueryActions,
+    SearchEngine,
+    SearchAppState,
+    loadQueryActions
+} from "@coveo/headless";
+import { buildSearchEngine, getSidebarSearchParams } from "utils/coveo";
+import { RecentSearches } from "utils/recentSearches";
+import { toJson } from "utils/normalizers";
+import {
+    Option,
+    PopoverRequestCloseType,
+    SidebarSearchResult
+} from "typings/custom";
+
+export const SESSION_KEY = "dx-sidebar-search-state";
+
+const DEFAULT_RESULT_COUNT = 20;
+const SEARCH_DEBOUNCE_DELAY = 780;
+
+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;
+    }
+    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;
+
+        if (hasChanged && this.engine) {
+            // set advanced filters needs access to the latest coveoAdvancedQueryConfig
+            this.dispatchOnLoading(true);
+            this.setAdvancedFilters(this.engine);
+            this.submitSearch(true);
+        }
+    }
+
+    @api
+    public fetchMoreResults() {
+        if (this.resultList?.state?.moreResultsAvailable) {
+            this.fetchingMoreResults = true;
+            this.resultList.fetchMoreResults();
+        }
+    }
+
+    @api
+    setInputValue(searchTerm: string) {
+        this.value = searchTerm || "";
+        this.handleValueChange(true);
+    }
+
+    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 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 get isDropdownOpen() {
+        return (
+            this.dropdownRequestedOpen &&
+            this.recentSearches &&
+            this.recentSearches.length > 0 &&
+            !this.value
+        );
+    }
+
+    constructor() {
+        super();
+
+        this.updateRecentSearches();
+        this.value = getSidebarSearchParams() || "";
+    }
+
+    disconnectedCallback() {
+        this.unsubscribeFromResultList();
+    }
+
+    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 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;
+        }
+
+        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);
+            }
+        } 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
+            });
+        } 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
+            }
+        });
+
+        this.searchBox = buildSearchBox(this.engine, {
+            options: { numberOfSuggestions: 3 }
+        });
+
+        this.setAdvancedFilters(this.engine);
+
+        this.unsubscribeFromResultList = this.resultList?.subscribe(
+            this.onResultListChange
+        );
+
+        if (this.value) {
+            this.dispatchHighlightedTermChange();
+        }
+
+        if (!this.preloadedState) {
+            if (this.value) {
+                this.submitSearch();
+            } else {
+                this.dispatchOnLoading(false);
+            }
+        }
+    };
+
+    private onResultListChange = () => {
+        if (!this.resultList) {
+            return;
+        }
+
+        const { isLoading, firstSearchExecuted, results } =
+            this.resultList.state;
+
+        if ((!firstSearchExecuted && !isLoading) || !this.value) {
+            // coveo search is firing off some unwanted payloads on startup
+            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
+        });
+
+        engine.dispatch(registerSearchQueryAction);
+    }
+
+    private normalizeCoveoResult = ({
+        clickUri,
+        excerpt,
+        excerptHighlights,
+        raw: { sfhtml_url__c },
+        title,
+        titleHighlights,
+        uniqueId
+    }: Result): SidebarSearchResult => {
+        // discussion about this normalization here: https://salesforce-internal.slack.com/archives/C020S6784JX/p1639506238376600
+        const extension =
+            this.coveoAdvancedQueryConfig.path_segment_4 === "references"
+                ? ""
+                : ".html";
+        const pathname = sfhtml_url__c
+            ? `/docs/${sfhtml_url__c}`
+            : `${new URL(clickUri).pathname}${extension}`;
+        const href = `${pathname}?q=${this.value}`;
+
+        return {
+            title,
+            titleHighlights,
+            excerpt,
+            excerptHighlights,
+            uniqueId,
+            href,
+            selected: pathname === window.location.pathname
+        };
+    };
+
+    private updateSessionStorage() {
+        window.sessionStorage.setItem(
+            SESSION_KEY,
+            JSON.stringify({
+                coveoAdvancedQueryConfig: this.coveoAdvancedQueryConfig,
+                state: this.engine?.state
+            })
+        );
+    }
+
+    private dispatchOnChangeEvent(results: Result[]) {
+        this.updateSessionStorage();
+        this.dispatchEvent(
+            new CustomEvent("change", {
+                detail: {
+                    results: results.map(this.normalizeCoveoResult),
+                    value: this.value
+                }
+            })
+        );
+    }
+
+    private dispatchOnLoading(loading: boolean) {
+        this.dispatchEvent(new CustomEvent("loading", { detail: loading }));
+    }
+
+    private dispatchHighlightedTermChange() {
+        this.dispatchEvent(
+            new CustomEvent("highlightedtermchange", {
+                detail: this.value,
+                composed: true,
+                bubbles: true
+            })
+        );
+    }
+
+    private updateRecentSearches = () =>
+        (this.recentSearches = UserRecentSearches.get().map((item: string) => ({
+            id: item,
+            label: item
+        })));
+
+    private dispatchSidebarSearchChange(searchTerm: string | undefined): void {
+        this.dispatchEvent(
+            new CustomEvent("sidebarsearchchange", {
+                detail: searchTerm ?? "",
+                bubbles: true,
+                composed: true
+            })
+        );
+    }
+
+    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();
+        }
+    }, SEARCH_DEBOUNCE_DELAY);
+
+    private onClickRecentSearch(e: CustomEvent) {
+        this.value = e.detail;
+        this.dispatchSidebarSearchChange(this.value);
+        this.submitSearch(true);
+    }
+
+    private onDropdownRequestClose(e: CustomEvent) {
+        switch (e.detail as PopoverRequestCloseType) {
+            case "interact-outside":
+            case "keypress-escape":
+                this.dropdownRequestedOpen = false;
+                break;
+            default:
+                break;
+        }
+    }
+
+    private onInputChange(e: CustomEvent) {
+        this.value = e.detail;
+
+        this.handleValueChange(false);
+        this.dispatchHighlightedTermChange();
+    }
+
+    private onInputFocus() {
+        this.dropdownRequestedOpen = true;
+    }
+
+    private onInputClear() {
+        this.dropdownRequestedOpen = false;
+    }
+
+    private handleValueChange(isSyncingSearchValue = false) {
+        if (this.value) {
+            this.dispatchOnLoading(true);
+            if (this.searchBox) {
+                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.dispatchSidebarSearchChange(this.value);
+        }
+    }
+}

package/src/modules/dx/sidebarSearchResult/__tests__/sidebarSearchResult.test.ts

@@ -0,0 +1,55 @@
+import SidebarSearchResult from "dx/sidebarSearchResult";
+import { createRenderComponent } from "utils/tests";
+
+const TAG = "dx-sidebar-search-result";
+const render = createRenderComponent(TAG, SidebarSearchResult);
+
+const PROPS = {
+    description: "test description here",
+    descriptionHighlights: [{ length: 5, offset: 5 }],
+    href: "/test",
+    selected: false,
+    title: "test title here",
+    titleHighlights: [{ length: 5, offset: 5 }]
+};
+
+describe(TAG, () => {
+    it("renders a result with the correct highlighted content", () => {
+        const element = render(PROPS);
+
+        const titleBolds = element.shadowRoot.querySelectorAll(".title .bold");
+        expect(titleBolds.length).toEqual(1);
+        expect(titleBolds[0].textContent).toEqual("title");
+
+        const descriptionBolds =
+            element.shadowRoot.querySelectorAll(".description .bold");
+        expect(descriptionBolds.length).toEqual(1);
+        expect(descriptionBolds[0].textContent).toEqual("descr");
+
+        return expect(element).toBeAccessible();
+    });
+
+    it("renders a result as selected when specified", () => {
+        const element = render({ ...PROPS, selected: true });
+
+        const selected = element.shadowRoot.querySelector(
+            ".sidebar-item-selected"
+        );
+        expect(selected).not.toBeNull();
+
+        return expect(element).toBeAccessible();
+    });
+
+    it("doesn't add bold class when there is no highlighted term", () => {
+        const element = render({
+            ...PROPS,
+            descriptionHighlights: [],
+            titleHighlights: []
+        });
+
+        const selected = element.shadowRoot.querySelector(".bold");
+        expect(selected).toBeNull();
+
+        return expect(element).toBeAccessible();
+    });
+});

package/src/modules/dx/sidebarSearchResult/sidebarSearchResult.css

@@ -0,0 +1,36 @@
+@import "helpers/reset";
+@import "helpers/text";
+@import "helpers/sidebar";
+
+a {
+    display: flex;
+    flex-direction: column;
+}
+
+.sidebar-item {
+    padding: var(--dx-g-spacing-smd) var(--dx-g-spacing-md);
+}
+
+.search-text {
+    font-size: var(--dx-g-text-xs);
+    font-family: var(--dx-g-font-sans);
+    line-height: 18px;
+    overflow-wrap: break-word;
+}
+
+.description {
+    -webkit-line-clamp: 3;
+    overflow-wrap: break-word;
+}
+
+.title {
+    color: var(--dx-g-text-heading-color);
+}
+
+.bold {
+    font-weight: 700;
+}
+
+a > *:not(:last-child) {
+    margin-bottom: 2px;
+}

package/src/modules/dx/sidebarSearchResult/sidebarSearchResult.html

@@ -0,0 +1,14 @@
+<template>
+    <a class={className} href={href}>
+        <span class="title search-text">
+            <template for:each={titleChunks} for:item="chunk">
+                <span class={chunk.class} key={chunk.id}>{chunk.value}</span>
+            </template>
+        </span>
+        <span class="description dx-text-body-3 sidebar-item-truncate-text">
+            <template for:each={descriptionChunks} for:item="chunk">
+                <span class={chunk.class} key={chunk.id}>{chunk.value}</span>
+            </template>
+        </span>
+    </a>
+</template>