@salesforcedevs/dx-components 0.0.0

package/src/modules/dx/sidebar/sidebar.ts

@@ -0,0 +1,258 @@
+import cx from "classnames";
+import { api, track } from "lwc";
+import {
+    TreeNode,
+    SidebarGtmAction,
+    SidebarSearchResult
+} from "typings/custom";
+import { track as trackAnalytics } from "dxUtils/analytics";
+import { getSidebarSearchParams } from "dxUtils/coveo";
+import { toJson } from "dxUtils/normalizers";
+import SidebarSearch from "dx/sidebarSearch";
+import { SidebarBase } from "dxBaseElements/sidebarBase";
+
+const MOBILE_SIZE_MATCH = "768px";
+const TOGGLE_BUTTON_LABEL = "Toggle Sidebar";
+
+export default class Sidebar extends SidebarBase {
+    @api coveoOrganizationId!: string;
+    @api coveoPublicAccessToken!: string;
+    @api coveoSearchHub!: string;
+    @api coveoAdvancedQueryConfig!: string;
+    @api header: string = "";
+
+    @api
+    get value() {
+        return this._value;
+    }
+
+    set value(value) {
+        this._value = value;
+    }
+
+    @api
+    get trees() {
+        return this._trees;
+    }
+
+    set trees(value: string | Array<TreeNode>) {
+        let parsedValue = toJson(value) || [];
+        if (parsedValue && !Array.isArray(parsedValue)) {
+            parsedValue = [parsedValue];
+        }
+
+        parsedValue.forEach((tree: TreeNode) => this.assignValueToLabel(tree));
+
+        this._trees = parsedValue.map((tree: TreeNode) => ({
+            key: this.makeKey(),
+            tree
+        }));
+    }
+
+    @api
+    setInputValue(searchTerm: string) {
+        (
+            this.template.querySelector(
+                "dx-sidebar-search"
+            ) as unknown as SidebarSearch
+        )?.setInputValue(searchTerm);
+    }
+
+    private expanded: boolean = true;
+    private _toggleHovered: boolean = false;
+    private _value?: string = undefined;
+
+    @track
+    private _trees!: Array<TreeNode>;
+
+    private mobile: boolean = true;
+    private matchMedia!: MediaQueryList;
+    private valueToLabel: { [key: string]: string } = {};
+
+    private isSearchLoading: boolean = false;
+    private searchValue: string | null = null;
+    private searchResults: SidebarSearchResult[] = [];
+    private scrollToSelectedSearchResult: boolean = false;
+    private selectedSearchResultIndex: number = -1;
+    private requestedFetchMoreResults: boolean = false;
+
+    private get areResultsEmpty(): boolean {
+        return (
+            (!this.searchResults ||
+                (this.searchResults && this.searchResults.length < 1)) &&
+            !this.isSearchLoading
+        );
+    }
+
+    private get isSearchEmpty(): boolean {
+        return this.isUserSearching && this.areResultsEmpty;
+    }
+
+    private get showResultsHeading(): boolean {
+        return this.isUserSearching && !this.areResultsEmpty;
+    }
+
+    private get isUserSearching(): boolean {
+        return !!this.searchValue || this.isSearchLoading;
+    }
+
+    private get showSearchResults(): boolean {
+        return (
+            !!this.searchValue && !this.isSearchLoading && !this.areResultsEmpty
+        );
+    }
+
+    private get isNearBottomOfSearchResults(): boolean {
+        const scrollArea = this.template.querySelector(
+            ".sidebar-content-search"
+        );
+        if (!scrollArea) {
+            return false;
+        }
+
+        const { scrollHeight, scrollTop } = scrollArea;
+        const { height } = scrollArea?.getBoundingClientRect();
+
+        return scrollHeight - scrollTop - height < 300;
+    }
+
+    private get containerClass() {
+        return cx("container", {
+            collapsed: !this.expanded,
+            "container-border-active": this._toggleHovered,
+            "container-mobile": this.mobile,
+            "user-searching": this.isUserSearching,
+            "show-tree": !this.isUserSearching,
+            "search-empty": this.isSearchEmpty
+        });
+    }
+
+    private get headerMobile() {
+        return (
+            (this.value && this.valueToLabel[this.value]) ||
+            Object.values(this.valueToLabel)[0] ||
+            ""
+        );
+    }
+
+    constructor() {
+        super();
+
+        if (getSidebarSearchParams()) {
+            this.isSearchLoading = true;
+            this.scrollToSelectedSearchResult = true;
+        }
+    }
+
+    renderedCallback() {
+        super.renderedCallback();
+        this.initializeSearchScrollPosition();
+    }
+
+    connectedCallback() {
+        this.matchMedia = window.matchMedia(
+            `(max-width: ${MOBILE_SIZE_MATCH})`
+        );
+
+        this.expanded = !this.matchMedia.matches;
+        this.onMediaChange(this.matchMedia);
+        this.matchMedia.addEventListener("change", this.onMediaChange);
+    }
+
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.matchMedia.removeEventListener("change", this.onMediaChange);
+    }
+
+    private onMediaChange = (event: MediaQueryListEvent | MediaQueryList) =>
+        (this.mobile = event.matches);
+
+    private onSelect(event: CustomEvent) {
+        this._value = event.detail.name;
+    }
+
+    private onToggleClick(event: Event) {
+        this.expanded = !this.expanded;
+        this._toggleHovered = false;
+        const sideNavAction: SidebarGtmAction = this.expanded
+            ? "expand"
+            : "collapse";
+        trackAnalytics(event.currentTarget!, "custEv_leftNavLinkClick", {
+            sideNavAction,
+            clickText: TOGGLE_BUTTON_LABEL
+        });
+    }
+
+    private onToggleMouseEnter() {
+        this._toggleHovered = true;
+    }
+
+    private onToggleMouseLeave() {
+        this._toggleHovered = false;
+    }
+
+    private makeKey(): string {
+        return Math.random().toString(36).substring(7);
+    }
+
+    private onSearchChange(e: CustomEvent) {
+        this.requestedFetchMoreResults = false;
+        this.searchResults = e.detail.results;
+        this.searchValue = e.detail.value;
+    }
+
+    private onSearchLoading(e: CustomEvent) {
+        if (!e.detail.loading && this.scrollToSelectedSearchResult) {
+            this.selectedSearchResultIndex = this.searchResults.findIndex(
+                (r) => r.selected
+            );
+        }
+        this.isSearchLoading = e.detail;
+    }
+
+    private onSidebarSearchContentScroll() {
+        if (this.isSearchLoading) {
+            return;
+        }
+
+        const search = this.template.querySelector(
+            "dx-sidebar-search"
+        ) as unknown as SidebarSearch;
+
+        if (
+            this.isNearBottomOfSearchResults &&
+            search &&
+            !this.requestedFetchMoreResults
+        ) {
+            this.requestedFetchMoreResults = true;
+            search.fetchMoreResults();
+        }
+    }
+
+    private initializeSearchScrollPosition() {
+        if (
+            this.scrollToSelectedSearchResult &&
+            this.selectedSearchResultIndex >= 0
+        ) {
+            const selectedResult = this.template.querySelector(
+                `dx-sidebar-search-result:nth-child(${
+                    this.selectedSearchResultIndex + 1
+                })`
+            );
+            if (!selectedResult || !selectedResult.parentNode) {
+                return;
+            }
+            (selectedResult.parentNode as HTMLElement).scrollTop =
+                selectedResult.offsetTop -
+                (selectedResult.parentNode as HTMLElement).offsetTop;
+            this.scrollToSelectedSearchResult = false;
+        }
+    }
+
+    private assignValueToLabel(node: TreeNode): void {
+        this.valueToLabel[node.name] = node.label;
+        if (node.children && node.children.length > 0) {
+            node.children.forEach((child) => this.assignValueToLabel(child));
+        }
+    }
+}

package/src/modules/dx/sidebarOld/sidebarOld.css

@@ -0,0 +1,16 @@
+@import "dxHelpers/commonSidebar";
+
+.collapsed .header-toggle-button {
+    transform: rotate(180deg);
+}
+
+.sidebar-content {
+    overflow-y: auto;
+}
+
+dx-empty-state {
+    --dx-c-empty-state-background: var(--sds-g-gray-2);
+    --dx-c-empty-state-image-width: 400px;
+
+    padding-bottom: var(--dx-g-spacing-md);
+}

package/src/modules/dx/sidebarOld/sidebarOld.html

@@ -0,0 +1,74 @@
+<template>
+    <div class={containerClass}>
+        <div
+            if:true={mobile}
+            class="header padding-horizontal"
+            onclick={onToggleClick}
+        >
+            <span class="header-title truncate">{headerMobile}</span>
+            <div class="header-toggle-icon">
+                <dx-icon
+                    aria-expanded={expanded}
+                    aria-label="icon"
+                    sprite="utility"
+                    symbol="chevrondown"
+                ></dx-icon>
+            </div>
+        </div>
+
+        <dx-button
+            if:false={mobile}
+            aria-expanded={expanded}
+            aria-label="icon"
+            class="header-toggle-button"
+            icon-symbol="close_panel"
+            variant="custom"
+            onclick={onToggleClick}
+            onmouseenter={onToggleMouseEnter}
+            onmouseleave={onToggleMouseLeave}
+        ></dx-button>
+
+        <template if:true={expanded}>
+            <div class="padding-horizontal">
+                <div class="header" if:false={mobile}>
+                    <h2 class="dx-text-heading-4 header-title">{header}</h2>
+                    <slot name="header"></slot>
+                </div>
+                <div class="search">
+                    <dx-input
+                        class="search-box"
+                        type="search"
+                        placeholder="Search"
+                        role="search"
+                        aria-label="Content Search"
+                        icon-symbol="search"
+                        size="small"
+                        value={searchText}
+                        onchange={onSearchChange}
+                        shortcut-key="j"
+                    ></dx-input>
+                </div>
+            </div>
+            <div
+                class="sidebar-content sidebar-content-tree"
+                if:true={anyResultMatch}
+            >
+                <dx-tree
+                    for:each={filteredTrees}
+                    for:item="tree"
+                    key={tree.key}
+                    tree-root={tree.tree}
+                    onselect={onSelect}
+                    value={value}
+                    onselecteditemrendered={onSelectedItemRendered}
+                ></dx-tree>
+            </div>
+            <dx-empty-state
+                class="padding-horizontal"
+                size="small"
+                title="No Results"
+                if:false={anyResultMatch}
+            ></dx-empty-state>
+        </template>
+    </div>
+</template>

package/src/modules/dx/sidebarOld/sidebarOld.ts

@@ -0,0 +1,194 @@
+import cx from "classnames";
+import { track } from "dxUtils/analytics";
+import { api } from "lwc";
+
+import { TreeNode, SidebarGtmAction } from "typings/custom";
+import { toJson } from "dxUtils/normalizers";
+import { SidebarBase } from "dxBaseElements/sidebarBase";
+
+const WAIT_TIME = 500;
+const MOBILE_SIZE_MATCH = "768px";
+const TOGGLE_BUTTON_LABEL = "Toggle Sidebar";
+
+export default class Sidebar extends SidebarBase {
+    @api header: string = "";
+
+    @api
+    get value() {
+        return this._value;
+    }
+
+    set value(value) {
+        this._value = value;
+    }
+
+    @api
+    get trees() {
+        return this._trees;
+    }
+
+    set trees(value: string | Array<TreeNode>) {
+        let parsedValue = toJson(value);
+        if (parsedValue && !Array.isArray(parsedValue)) {
+            parsedValue = [parsedValue];
+        }
+
+        this._trees = parsedValue || [];
+
+        this._trees.forEach((tree) => this.assignValueToLabel(tree));
+        this.assignFilteredTrees();
+    }
+
+    private expanded: boolean = true;
+    private _toggleHovered: boolean = false;
+    private _searchTimeout?: number;
+    private _value?: string = undefined;
+    private _trees!: Array<TreeNode>;
+
+    private filteredTrees: Array<{ key: string; tree: TreeNode }> = [];
+    private mobile: boolean = true;
+    private searchText: string = "";
+    private matchMedia!: MediaQueryList;
+    private valueToLabel: { [key: string]: string } = {};
+
+    private get anyResultMatch() {
+        return this.filteredTrees.length > 0;
+    }
+
+    private get containerClass() {
+        return cx("container", {
+            collapsed: !this.expanded,
+            "container-border-active": this._toggleHovered,
+            "container-mobile": this.mobile
+        });
+    }
+
+    private get headerMobile() {
+        return (
+            (this.value && this.valueToLabel[this.value]) ||
+            Object.values(this.valueToLabel)[0] ||
+            ""
+        );
+    }
+
+    connectedCallback() {
+        this.matchMedia = window.matchMedia(
+            `(max-width: ${MOBILE_SIZE_MATCH})`
+        );
+
+        this.expanded = !this.matchMedia.matches;
+        this.onMediaChange(this.matchMedia);
+        this.matchMedia.addEventListener("change", this.onMediaChange);
+    }
+
+    renderedCallback() {
+        super.renderedCallback();
+    }
+
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.matchMedia.removeEventListener("change", this.onMediaChange);
+    }
+
+    private onMediaChange = (event: MediaQueryListEvent | MediaQueryList) =>
+        (this.mobile = event.matches);
+
+    private onSelect(event: CustomEvent) {
+        this._value = event.detail.name;
+    }
+
+    private onToggleClick(event: Event) {
+        this.expanded = !this.expanded;
+        this._toggleHovered = false;
+        const sideNavAction: SidebarGtmAction = this.expanded
+            ? "expand"
+            : "collapse";
+        track(event.currentTarget!, "custEv_leftNavLinkClick", {
+            sideNavAction,
+            clickText: TOGGLE_BUTTON_LABEL
+        });
+    }
+
+    private onToggleMouseEnter() {
+        this._toggleHovered = true;
+    }
+
+    private onToggleMouseLeave() {
+        this._toggleHovered = false;
+    }
+
+    /*
+     * Debouncing this method: Do not apply searchText filter as long as this
+     * function is being called to avoid running the recursivity logic very often.
+     **/
+    private onSearchChange(event: CustomEvent) {
+        this.searchText = event.detail;
+        window.clearTimeout(this._searchTimeout);
+        this._searchTimeout = window.setTimeout(() => {
+            this.assignFilteredTrees();
+            this.dispatchEvent(
+                new CustomEvent("highlightedtermchange", {
+                    detail: this.searchText,
+                    composed: true,
+                    bubbles: true
+                })
+            );
+        }, WAIT_TIME);
+    }
+
+    private assignFilteredTrees() {
+        this.filteredTrees = this._trees
+            .map((singleTree) => {
+                return {
+                    key: this.makeKey(),
+                    tree: this.searchText
+                        ? this.findMatch(
+                              new RegExp(this.searchText.toLowerCase().trim()),
+                              singleTree
+                          )!
+                        : singleTree
+                };
+            })
+            .filter((filteredTree) => filteredTree.tree);
+    }
+
+    private makeKey(): string {
+        return Math.random().toString(36).substring(7);
+    }
+
+    private findMatch(
+        valuePattern: RegExp,
+        node: TreeNode
+    ): TreeNode | undefined {
+        const isExpanded = node.isChildrenLoading ? false : true;
+        if (valuePattern.test(node.label.toLowerCase())) {
+            return { ...node, isExpanded };
+        }
+
+        const filteredChildren = this.filterChildren(
+            valuePattern,
+            node.children
+        );
+        return filteredChildren.length > 0
+            ? { ...node, children: filteredChildren, isExpanded }
+            : undefined;
+    }
+
+    private filterChildren(
+        valuePattern: RegExp,
+        children?: Array<TreeNode>
+    ): Array<TreeNode> {
+        return !children || children.length === 0
+            ? []
+            : (children
+                  .map((child) => this.findMatch(valuePattern, child))
+                  .filter((child) => child) as Array<TreeNode>);
+    }
+
+    private assignValueToLabel(node: TreeNode): void {
+        this.valueToLabel[node.name] = node.label;
+        if (node.children && node.children.length > 0) {
+            node.children.forEach((child) => this.assignValueToLabel(child));
+        }
+    }
+}

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"
+            role="search"
+            aria-label="Search in this guide"
+            icon-symbol="search"
+            size="small"
+            value={value}
+            onchange={onInputChange}
+            onfocus={onInputFocus}
+            onclear={onInputClear}
+            shortcut-key="j"
+            clearable
+        ></dx-input>
+    </dx-dropdown>
+</template>