@athoscommerce/snap-preact 1.10.0 → 1.10.1-beta.150

package/dist/esm/components/src/components/Organisms/Chat/components/ChatComposer.js

@@ -0,0 +1,160 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "@emotion/react/jsx-runtime";
+import { css } from '@emotion/react';
+import classnames from 'classnames';
+import deepmerge from 'deepmerge';
+import { observer } from 'mobx-react-lite';
+import { CHAT_MAX_MESSAGE_LENGTH } from '@athoscommerce/snap-client';
+import { useTheme, CacheProvider, useTreePath } from '../../../../providers';
+import { mergeProps, mergeStyles } from '../../../../utilities';
+import { Button } from '../../../Atoms/Button';
+import { chatDefaultLang, langAttrOf, langTextOf } from '../Chat.lang';
+// show the character counter only when the user is approaching the limit
+const CHAR_COUNTER_THRESHOLD = 200;
+const defaultStyles = ({ primaryColorBg, primaryColorFg }) => {
+    const colorPrimary = primaryColorBg;
+    const colorPrimaryText = primaryColorFg;
+    return css({
+        display: 'flex',
+        flexDirection: 'column',
+        gap: '8px',
+        flexShrink: 0,
+        '.ss__chat__input': {
+            display: 'flex',
+            justifyContent: 'space-between',
+            gap: '8px',
+            flexShrink: 0,
+            '.ss__chat__input__input': {
+                flex: '1 1 0%',
+                minWidth: 0,
+                border: '1px solid #ccc',
+                borderRadius: '2em',
+                display: 'flex',
+                justifyContent: 'space-between',
+                overflow: 'auto',
+                '&:has(input:disabled)': {
+                    backgroundColor: '#f5f5f5',
+                },
+                'input[type="text"]': {
+                    padding: '0.5em 0',
+                    margin: '0 0 0 1em',
+                    flex: '1 0 auto',
+                    border: 'none',
+                    backgroundColor: 'transparent',
+                    '&::placeholder': {
+                        color: '#999',
+                        opacity: 0.7,
+                    },
+                    '&:focus': {
+                        outline: 'none',
+                        borderColor: colorPrimary,
+                    },
+                    '&:disabled': {
+                        backgroundColor: 'transparent',
+                    },
+                },
+                '.ss__button': {
+                    margin: '0 0.5em 0 0',
+                    backgroundColor: 'transparent',
+                    '&:hover': {
+                        backgroundColor: 'transparent',
+                    },
+                    '&:disabled': {
+                        backgroundColor: 'transparent',
+                    },
+                },
+                'input[type="file"]': {
+                    display: 'none',
+                },
+                '.ss__chat__input__counter': {
+                    alignSelf: 'center',
+                    flexShrink: 0,
+                    fontSize: '10px',
+                    color: '#999',
+                    padding: '0 0.75em',
+                    whiteSpace: 'nowrap',
+                },
+            },
+            '.ss__chat__input__actions': {
+                '.ss__button': {
+                    backgroundColor: colorPrimary,
+                    color: colorPrimaryText,
+                    borderRadius: '50%',
+                    height: '3em',
+                    width: '3em',
+                    cursor: 'pointer',
+                    justifyContent: 'center',
+                    boxSizing: 'border-box',
+                    '&:disabled': {
+                        opacity: 0.5,
+                        cursor: 'not-allowed',
+                    },
+                    svg: {
+                        fill: colorPrimaryText,
+                        stroke: colorPrimaryText,
+                    },
+                },
+            },
+        },
+        '.ss__chat__disclaimer': {
+            fontSize: '10px',
+            color: '#6A7282',
+            textAlign: 'center',
+            flexShrink: 0,
+        },
+    });
+};
+export const ChatComposer = observer((properties) => {
+    const globalTheme = useTheme();
+    const globalTreePath = useTreePath();
+    const defaultProps = {
+        poweredByText: 'Powered by Athos Commerce.',
+        treePath: globalTreePath,
+    };
+    const props = mergeProps('chatComposer', globalTheme, defaultProps, properties);
+    const { className, internalClassName, controller, fileInputRef, onUserSend, poweredByText, privacyPolicyUrl } = props;
+    const { store } = controller;
+    const lang = deepmerge(chatDefaultLang, props.lang || {});
+    const styling = mergeStyles(props, defaultStyles);
+    const inputDisabled = store.loading || store.blocked || store.currentChat?.sessionLimitReached || store.chatEnabled === false;
+    const placeholder = (() => {
+        const comparedCount = store.currentChat?.comparisons.compared.length || 0;
+        const committedCount = store.currentChat?.comparisons.committed.length || 0;
+        const attached = store.currentChat?.attachments.attached.filter((item) => item.state === 'attached' || item.state === 'active') || [];
+        const attachedProducts = attached.filter((item) => item.type === 'product');
+        const attachedImages = attached.filter((item) => item.type === 'image' && !item.error);
+        if (attachedProducts.length === 1) {
+            return langTextOf(lang.inputPlaceholderAskProduct);
+        }
+        if (comparedCount > 1 || attachedProducts.length > 1) {
+            return langTextOf(lang.inputPlaceholderCompare);
+        }
+        if (committedCount > 0) {
+            return langTextOf(lang.inputPlaceholderComparedProducts);
+        }
+        if (attachedImages.length > 0) {
+            return langTextOf(lang.inputPlaceholderAskImage);
+        }
+        if (comparedCount === 1) {
+            return langTextOf(lang.inputPlaceholderAddCompare);
+        }
+        return langTextOf(lang.inputPlaceholder);
+    })();
+    const hasImageAttachment = (store.currentChat?.attachments.attached || []).some((item) => item.type === 'image' && !item.error);
+    const messageEmpty = !controller.store.inputValue.trim();
+    const sendDisabled = store.blocked || store.currentChat?.sessionLimitReached || store.chatEnabled === false || (hasImageAttachment && messageEmpty) || messageEmpty;
+    return (_jsx(CacheProvider, { children: _jsxs("div", { ...styling, className: classnames('ss__chat__composer', className, internalClassName), children: [_jsxs("div", { className: 'ss__chat__input', children: [_jsxs("div", { className: 'ss__chat__input__input', children: [_jsx("input", { type: "text", name: "ss-chat-input", maxLength: CHAT_MAX_MESSAGE_LENGTH, disabled: inputDisabled, placeholder: placeholder, onInput: (e) => controller.handlers.input.input(e), onKeyDown: (e) => {
+                                        controller.handlers.input.enterKey(e);
+                                        if (e.key === 'Enter') {
+                                            onUserSend && onUserSend();
+                                        }
+                                    }, value: controller.store.inputValue }), controller.store.inputValue.length >= CHAR_COUNTER_THRESHOLD && (_jsx("span", { className: 'ss__chat__input__counter', children: `${controller.store.inputValue.length}/${CHAT_MAX_MESSAGE_LENGTH}` })), store.features.imageSearch.enabled && (_jsxs(_Fragment, { children: [_jsx(Button, { className: 'ss__chat__upload-button', disabled: inputDisabled, onClick: () => fileInputRef.current?.click(), "aria-label": langAttrOf(lang.uploadImageButton, 'aria-label'), icon: { icon: 'image', title: langAttrOf(lang.uploadImageButton, 'title') } }), _jsx("input", { ref: fileInputRef, onChange: async (e) => {
+                                                await controller.upload(e.target.files);
+                                                // reset value
+                                                e.target.value = '';
+                                            }, type: "file", accept: "image/*", className: "ss__chat__input__input__file" })] }))] }), _jsx("div", { className: 'ss__chat__input__actions', children: _jsx(Button, { className: "ss__chat__send-button", "aria-label": langAttrOf(lang.sendMessageButton, 'aria-label'), icon: { icon: 'send', title: langAttrOf(lang.sendMessageButton, 'title') }, disabled: sendDisabled, onClick: () => {
+                                    if (sendDisabled)
+                                        return;
+                                    controller.search();
+                                    onUserSend && onUserSend();
+                                } }) })] }), _jsx("div", { className: 'ss__chat__disclaimer', children: _jsxs("i", { children: [poweredByText, " ", langTextOf(lang.disclaimerText), privacyPolicyUrl && (_jsxs(_Fragment, { children: [' ', _jsx("a", { href: privacyPolicyUrl, target: "_blank", rel: "noopener noreferrer", children: langTextOf(lang.privacyPolicyLinkText) })] }))] }) })] }) }));
+});

package/dist/esm/components/src/components/Organisms/Chat/components/ChatFacetsBar.d.ts

@@ -0,0 +1,18 @@
+import { RefObject } from 'preact';
+import type { ChatController } from '@athoscommerce/snap-controller';
+import { ComponentProps } from '../../../../types';
+import { ChatLang } from '../Chat.lang';
+export declare const ChatFacetsBar: ((properties: ChatFacetsBarProps) => JSX.Element | null) & {
+    displayName: string;
+};
+export type ChatFacetsBarProps = {
+    controller: ChatController;
+    chatRef: RefObject<HTMLDivElement>;
+    multiselectFacets?: boolean;
+    /** Maximum number of facets rendered in the bar. */
+    facetLimit?: number;
+    lang?: Partial<ChatLang>;
+    primaryColorBg?: string;
+    primaryColorFg?: string;
+} & ComponentProps<ChatFacetsBarProps>;
+//# sourceMappingURL=ChatFacetsBar.d.ts.map

package/dist/esm/components/src/components/Organisms/Chat/components/ChatFacetsBar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatFacetsBar.d.ts","sourceRoot":"","sources":["../../../../../../../../components/src/components/Organisms/Chat/components/ChatFacetsBar.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAK,SAAS,EAAE,MAAM,QAAQ,CAAC;AAQtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAIrE,OAAO,EAAE,cAAc,EAAe,MAAM,mBAAmB,CAAC;AAOhE,OAAO,EAAE,QAAQ,EAA+B,MAAM,cAAc,CAAC;AAgLrE,eAAO,MAAM,aAAa,gBAAyB,kBAAkB,KAAG,GAAG,CAAC,OAAO,GAAG,IAAI;;CAiTxF,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG;IAChC,UAAU,EAAE,cAAc,CAAC;IAC3B,OAAO,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;IACnC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,oDAAoD;IACpD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,cAAc,CAAC,kBAAkB,CAAC,CAAC"}

package/dist/esm/components/src/components/Organisms/Chat/components/ChatFacetsBar.js

@@ -0,0 +1,363 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@emotion/react/jsx-runtime";
+import { useRef, useEffect, useState } from 'preact/hooks';
+import { css } from '@emotion/react';
+import classnames from 'classnames';
+import deepmerge from 'deepmerge';
+import { observer } from 'mobx-react-lite';
+import { useTheme, CacheProvider, useTreePath } from '../../../../providers';
+import { Colour, defined, mergeProps, mergeStyles } from '../../../../utilities';
+import { useLang } from '../../../../hooks';
+import { useA11y } from '../../../../hooks/useA11y';
+import { Button } from '../../../Atoms/Button';
+import { Dropdown } from '../../../Atoms/Dropdown';
+import { Icon } from '../../../Atoms/Icon';
+import { FacetSlider } from '../../../Molecules/FacetSlider';
+import { chatDefaultLang, langTextOf } from '../Chat.lang';
+/** Range buckets are identified by their bounds, every other option by its value string.
+ * The store takes the shape as-is, so the discriminator never round-trips through a string. */
+const facetOptionValue = (option) => {
+    if (option && ('low' in option || 'high' in option)) {
+        const range = option;
+        return { low: range.low, high: range.high };
+    }
+    return option?.value || option?.label || '';
+};
+const facetOptionKey = (value) => (typeof value === 'string' ? value : `${value.low ?? '*'}:${value.high ?? '*'}`);
+const defaultStyles = ({ primaryColorBg, primaryColorFg }) => {
+    const colorPrimary = primaryColorBg;
+    const colorPrimaryText = primaryColorFg;
+    return css({
+        display: 'flex',
+        flexDirection: 'column',
+        gap: '6px',
+        overflow: 'hidden',
+        '.ss__chat__actions__wrap': {
+            display: 'flex',
+            flexDirection: 'column',
+            gap: '6px',
+            padding: '8px 10px',
+            background: new Colour(colorPrimary).mixWhite(0.95),
+            border: `1px solid ${new Colour(colorPrimary).mixWhite(0.85)}`,
+            borderRadius: '8px',
+        },
+        '.ss__chat__actions--title': {
+            fontSize: '14px',
+            color: '#333',
+        },
+        '.ss__chat__actions--facets': {
+            display: 'flex',
+            flexDirection: 'row',
+            gap: '6px',
+            overflowX: 'auto',
+            overflowY: 'hidden',
+            scrollbarWidth: 'none',
+            '&::-webkit-scrollbar': {
+                display: 'none',
+            },
+            '.ss__button': {
+                flex: '0 0 auto',
+                background: '#fff',
+                border: '1px solid #ddd',
+                borderRadius: '999px',
+                padding: '3px 10px',
+                fontSize: '14px',
+                color: '#333',
+                '&:hover': {
+                    background: new Colour(colorPrimary).mixWhite(0.97),
+                },
+            },
+        },
+        '.ss__chat__actions__facet': {
+            padding: '1px', // make room for outline when focused
+            flexShrink: 0,
+        },
+        '.ss__chat__actions__facets-header': {
+            display: 'flex',
+            justifyContent: 'space-between',
+            alignItems: 'center',
+        },
+        '.ss__chat__actions__facets-apply': {
+            display: 'flex',
+            justifyContent: 'flex-end',
+            padding: '0 2px',
+            // reserve the slot so toggling the button's visibility doesn't reflow the header
+            visibility: 'hidden',
+            '&.ss__chat__actions__facets-apply--active': {
+                visibility: 'visible',
+            },
+            '.ss__button': {
+                background: colorPrimary,
+                color: colorPrimaryText,
+                border: 'none',
+                borderRadius: '999px',
+                padding: '2px 10px',
+                fontSize: '12px',
+                lineHeight: '1.4',
+                cursor: 'pointer',
+                '&:not(.ss__button--disabled):hover': {
+                    background: new Colour(colorPrimary).mixBlack(),
+                },
+                '&.ss__button--disabled': {
+                    opacity: 0.5,
+                    cursor: 'not-allowed',
+                },
+            },
+        },
+    });
+};
+const FacetButton = (props) => _jsx(Button, { icon: props.open ? 'angle-down' : 'angle-up', children: props.label });
+// Slider dropdown grows to fill the remaining chat width from its anchor,
+// so the price range slider isn't cramped inside a 150px-wide dropdown.
+const SliderFacetDropdown = observer((props) => {
+    const { facet, label, controller, chatRef, multiselectFacets, subProps } = props;
+    const anchorRef = useRef(null);
+    const [width, setWidth] = useState(null);
+    useEffect(() => {
+        const compute = () => {
+            if (!anchorRef.current || !chatRef.current)
+                return;
+            const anchor = anchorRef.current.getBoundingClientRect();
+            const chat = chatRef.current.getBoundingClientRect();
+            const remaining = chat.right - anchor.left - 16;
+            setWidth(Math.max(220, remaining));
+        };
+        compute();
+        const ro = typeof ResizeObserver !== 'undefined' ? new ResizeObserver(compute) : null;
+        if (ro && chatRef.current)
+            ro.observe(chatRef.current);
+        window.addEventListener('resize', compute);
+        return () => {
+            if (ro)
+                ro.disconnect();
+            window.removeEventListener('resize', compute);
+        };
+    }, []);
+    return (_jsx("div", { ref: anchorRef, className: "ss__chat__actions__facet ss__chat__actions__facet--range", children: _jsx(Dropdown, { ...subProps.dropdown, usePortal: true, dropUp: true, button: _jsx(FacetButton, { label: label }), style: {
+                '.ss__dropdown__content': {
+                    width: width ? `${width}px` : 'auto',
+                    background: 'white',
+                    boxShadow: '0px 3px 6px 0px rgba(0, 0, 0, 0.2)',
+                    borderRadius: '6px',
+                },
+            }, children: _jsx("div", { className: "ss__chat__actions__facet__options", children: _jsx("div", { className: "ss__chat__actions__facet__slider", style: { padding: '12px 16px' }, children: _jsx(FacetSlider, { ...subProps.facetSlider, facet: facet, onChange: () => {
+                            if (!multiselectFacets) {
+                                // FacetSlider fires onChange before its urlManager update; defer
+                                // so controller.search() reads the updated filter state. Force
+                                // productSearch with the current filters so a slider tweak doesn't
+                                // fall through to `general` when hasPendingFacetChanges happens to
+                                // be false (e.g. the slider returned to the seeded range).
+                                queueMicrotask(() => controller.search({
+                                    data: { requestType: 'productSearch', searchFilters: controller.store.searchFilters },
+                                }));
+                            }
+                        } }) }) }) }) }));
+});
+export const ChatFacetsBar = observer((properties) => {
+    const globalTheme = useTheme();
+    const globalTreePath = useTreePath();
+    const defaultProps = {
+        facetLimit: 10,
+        treePath: globalTreePath,
+    };
+    const props = mergeProps('chatFacetsBar', globalTheme, defaultProps, properties);
+    const { className, internalClassName, controller, chatRef, multiselectFacets, facetLimit, primaryColorBg, primaryColorFg, disableStyles, treePath, } = props;
+    const { store } = controller;
+    const colorPrimary = primaryColorBg;
+    const colorPrimaryText = primaryColorFg;
+    const subProps = {
+        dropdown: {
+            // inherited props
+            ...defined({
+                disableStyles,
+            }),
+            // component theme overrides
+            theme: props?.theme,
+            treePath,
+        },
+        facetSlider: {
+            // inherited props
+            ...defined({
+                disableStyles,
+            }),
+            // component theme overrides
+            theme: props?.theme,
+            treePath,
+        },
+        button: {
+            // inherited props
+            ...defined({
+                disableStyles,
+            }),
+            // component theme overrides
+            theme: props?.theme,
+            treePath,
+        },
+        icon: {
+            // inherited props
+            ...defined({
+                disableStyles,
+            }),
+            // component theme overrides
+            theme: props?.theme,
+            treePath,
+        },
+    };
+    const lang = deepmerge(chatDefaultLang, props.lang || {});
+    const mergedLang = useLang({
+        facetsTitle: lang.facetsTitle,
+    }, { controller }, { activeBreakpoint: globalTheme?.activeBreakpoint });
+    const styling = mergeStyles(props, defaultStyles);
+    const getFacetButtonLabel = (facet) => {
+        const base = facet.label || facet.field;
+        // Slider facets show the active low-high range in the button when narrowed.
+        if (facet.type === 'range') {
+            const rangeFacet = facet;
+            const active = rangeFacet.active;
+            const range = rangeFacet.range;
+            if (active && range && (active.low !== range.low || active.high !== range.high)) {
+                return `${base} (${active.low ?? '*'}-${active.high ?? '*'})`;
+            }
+            return base;
+        }
+        // Count current selections from the urlManager (source of truth for live state).
+        // `value.filtered` reflects the server's snapshot at response time and goes stale
+        // once the user deselects locally.
+        const applied = (facet.values || []).filter((value) => {
+            if (!value)
+                return false;
+            return controller.store.isFacetSelected(facet.field, facetOptionValue(value));
+        }).length;
+        return applied > 0 ? `${base} (${applied})` : base;
+    };
+    const toggleFacetOption = (field, optionValue) => {
+        // Non-multiselect: clicking an already-selected value toggles it off.
+        // `addFacet` is idempotent against an existing urlManager value, so without
+        // the toggle the state wouldn't change, `hasPendingFacetChanges` would stay
+        // false, and the params getter would fall through to `general`.
+        if (controller.store.isFacetSelected(field, optionValue)) {
+            controller.store.removeFacet(field, optionValue);
+        }
+        else {
+            controller.store.addFacet({
+                key: field,
+                value: optionValue,
+            });
+        }
+    };
+    const renderFacetOption = (facet, optionValue, label) => {
+        const optionKey = facetOptionKey(optionValue);
+        if (multiselectFacets) {
+            const isSelected = controller.store.isFacetSelected(facet.field, optionValue);
+            return (_jsxs("div", { className: "ss__chat__actions__facet__option--checkbox", role: "checkbox", "aria-checked": isSelected, "aria-label": label, ref: (e) => useA11y(e), onClick: () => {
+                    if (isSelected) {
+                        controller.store.removeFacet(facet.field, optionValue);
+                    }
+                    else {
+                        controller.store.addFacet({
+                            key: facet.field,
+                            value: optionValue,
+                        });
+                    }
+                }, children: [_jsx("div", { className: classnames('ss__chat__actions__facet__option__checkbox', {
+                            'ss__chat__actions__facet__option__checkbox--checked': isSelected,
+                        }), children: isSelected && _jsx(Icon, { ...subProps.icon, icon: "check-thin", size: "10px" }) }), _jsx("span", { className: "ss__chat__actions__facet__option__label", children: label })] }, optionKey));
+        }
+        return (_jsx(Button, { className: classnames({
+                'ss__chat__actions__facet__option--selected': controller.store.isFacetSelected(facet.field, optionValue),
+            }), onClick: () => {
+                toggleFacetOption(facet.field, optionValue);
+                // Force productSearch with the current filter state rather than relying
+                // on the params getter's hasPendingFacetChanges promotion — a facet click
+                // in the chat is unambiguously a search intent.
+                controller.search({
+                    data: { requestType: 'productSearch', searchFilters: controller.store.searchFilters },
+                });
+            }, children: label }, optionKey));
+    };
+    if (!store.facets || store.facets.length === 0) {
+        return null;
+    }
+    return (_jsx(CacheProvider, { children: _jsx("div", { ...styling, className: classnames('ss__chat__actions', className, internalClassName), children: _jsxs("div", { className: "ss__chat__actions__wrap", children: [_jsxs("div", { className: "ss__chat__actions__facets-header", children: [_jsx("div", { className: "ss__chat__actions--title", ...mergedLang.facetsTitle?.all }), multiselectFacets && store.hasPendingFacetChanges && (_jsx("div", { className: 'ss__chat__actions__facets-apply ss__chat__actions__facets-apply--active', children: _jsx(Button, { onClick: () => {
+                                        controller.search();
+                                    }, children: store.pendingFacetCount > 0
+                                        ? langTextOf(lang.facetsApplyButton, { count: store.pendingFacetCount })
+                                        : langTextOf(lang.facetsClearButton) }) }))] }), _jsx("div", { className: "ss__chat__actions--facets", children: store.facets.slice(0, facetLimit).map((facet) => {
+                            // range/slider facets render via FacetSlider; everything else needs at least one value to be useful
+                            if (facet.type !== 'range' && !facet.values?.length)
+                                return null;
+                            if (facet.type === 'range') {
+                                return (_jsx(SliderFacetDropdown, { facet: facet, label: getFacetButtonLabel(facet), controller: controller, chatRef: chatRef, multiselectFacets: multiselectFacets, subProps: subProps }, facet.field));
+                            }
+                            return (_jsx("div", { className: `ss__chat__actions__facet ss__chat__actions__facet--${facet.type}`, children: _jsx(Dropdown, { ...subProps.dropdown, usePortal: true, dropUp: true, boundaryRef: chatRef, button: _jsx(FacetButton, { label: getFacetButtonLabel(facet) }), style: {
+                                        '.ss__dropdown__content': {
+                                            width: '150px',
+                                            maxHeight: '200px',
+                                            overflowY: 'auto',
+                                            background: 'white',
+                                            boxShadow: '0px 3px 6px 0px rgba(0, 0, 0, 0.2)',
+                                            borderRadius: '6px',
+                                            ...(multiselectFacets
+                                                ? {
+                                                    '.ss__chat__actions__facet__option--checkbox': {
+                                                        display: 'flex',
+                                                        alignItems: 'center',
+                                                        gap: '8px',
+                                                        padding: '6px 10px',
+                                                        cursor: 'pointer',
+                                                        width: '100%',
+                                                        boxSizing: 'border-box',
+                                                        background: '#fff',
+                                                        border: 'none',
+                                                        borderBottom: '1px solid #f0f0f0',
+                                                        '&:hover': {
+                                                            background: new Colour(colorPrimary).mixWhite(0.95),
+                                                        },
+                                                        '&:last-child': {
+                                                            borderBottom: 'none',
+                                                        },
+                                                        '.ss__chat__actions__facet__option__checkbox': {
+                                                            width: '16px',
+                                                            height: '16px',
+                                                            borderRadius: '3px',
+                                                            border: '2px solid #ccc',
+                                                            display: 'flex',
+                                                            alignItems: 'center',
+                                                            justifyContent: 'center',
+                                                            flexShrink: 0,
+                                                            '&.ss__chat__actions__facet__option__checkbox--checked': {
+                                                                background: colorPrimary,
+                                                                borderColor: colorPrimary,
+                                                                color: colorPrimaryText,
+                                                                svg: {
+                                                                    fill: colorPrimaryText,
+                                                                    stroke: colorPrimaryText,
+                                                                },
+                                                            },
+                                                        },
+                                                        '.ss__chat__actions__facet__option__label': {
+                                                            fontSize: '14px',
+                                                            color: '#333',
+                                                            flex: '1 1 auto',
+                                                            textAlign: 'left',
+                                                        },
+                                                    },
+                                                }
+                                                : {
+                                                    '.ss__button': {
+                                                        width: '100%',
+                                                        border: 'none',
+                                                        borderRadius: 0,
+                                                        boxSizing: 'border-box',
+                                                        background: '#fff',
+                                                        '&:hover': {
+                                                            background: new Colour(colorPrimary).mixWhite(0.95),
+                                                        },
+                                                        '&.ss__chat__actions__facet__option--selected': {
+                                                            fontWeight: 'bold',
+                                                        },
+                                                    },
+                                                }),
+                                        },
+                                    }, children: _jsx("div", { className: "ss__chat__actions__facet__options", children: facet.values.map((option) => renderFacetOption(facet, facetOptionValue(option), option?.label)) }) }) }, facet.field));
+                        }) })] }) }) }));
+});

package/dist/esm/components/src/components/Organisms/Chat/components/ChatHistory.d.ts

@@ -0,0 +1,11 @@
+import type { ChatController } from '@athoscommerce/snap-controller';
+import { ComponentProps } from '../../../../types';
+import { ChatLang } from '../Chat.lang';
+export declare const ChatHistory: ((properties: ChatHistoryProps) => JSX.Element) & {
+    displayName: string;
+};
+export type ChatHistoryProps = {
+    controller: ChatController;
+    lang?: Partial<ChatLang>;
+} & ComponentProps<ChatHistoryProps>;
+//# sourceMappingURL=ChatHistory.d.ts.map

package/dist/esm/components/src/components/Organisms/Chat/components/ChatHistory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChatHistory.d.ts","sourceRoot":"","sources":["../../../../../../../../components/src/components/Organisms/Chat/components/ChatHistory.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAGrE,OAAO,EAAE,cAAc,EAAe,MAAM,mBAAmB,CAAC;AAIhE,OAAO,EAAE,QAAQ,EAA2C,MAAM,cAAc,CAAC;AAoJjF,eAAO,MAAM,WAAW,gBAAyB,gBAAgB,KAAG,GAAG,CAAC,OAAO;;CA6B7E,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG;IAC9B,UAAU,EAAE,cAAc,CAAC;IAC3B,IAAI,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;CACzB,GAAG,cAAc,CAAC,gBAAgB,CAAC,CAAC"}