@envive-ai/react-hooks 0.3.40 → 0.3.42

package/dist/contexts/typesV3.js

@@ -94,6 +94,7 @@ let ColorsNamesVars = /* @__PURE__ */ function(ColorsNamesVars$1) {
 }({});
 let ButtonColorsVars = /* @__PURE__ */ function(ButtonColorsVars$1) {
 	ButtonColorsVars$1["LightButtonBackgroundColor"] = "envive-colors-button-light-background-color";
+	ButtonColorsVars$1["LightButtonBorderColor"] = "envive-colors-button-light-border-color";
 	ButtonColorsVars$1["LightButtonIconColor"] = "envive-colors-button-light-icon-color";
 	ButtonColorsVars$1["DarkButtonBackgroundColor"] = "envive-colors-button-dark-background-color";
 	ButtonColorsVars$1["DarkButtonIconColor"] = "envive-colors-button-dark-icon-color";
@@ -125,4 +126,4 @@ let WidgetTypeV3 = /* @__PURE__ */ function(WidgetTypeV3$1) {
 
 //#endregion
 export { AspectRatioCSSVar, BorderRadiusCSSVar, ButtonColorsVars, ColorsNamesVars, ConfigVersionEnum, FontFamilyCSSVar, FontSizeCSSVar, FontWeightCSSVar, LetterSpacingCSSVar, LineHeightCSSVar, ThemeCSSVar, WidgetTypeV3 };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"typesV3.js","names":[],"sources":["../../src/contexts/typesV3.ts"],"sourcesContent":["import { FloatingButtonLocation } from '@envive-ai/react-toolkit-v3/FloatingButton';\nimport { ImageGalleryImage, ImageGalleryLayout } from '@envive-ai/react-toolkit-v3/ImageGallery';\nimport { PromptButtonVariant } from '@envive-ai/react-toolkit-v3/PromptButton';\nimport { AnimationSpeed, PromptCarouselRows } from '@envive-ai/react-toolkit-v3/PromptCarousel';\nimport { DynamicLayout, WidgetKind } from '@envive-ai/react-toolkit-v3/SocialProof';\nimport { Theme } from '@envive-ai/react-toolkit-v3/Tokens';\nimport { SparkleIconColor } from '@envive-ai/react-toolkit-v3/WelcomeMessage';\nimport { WidgetWrapperVariant } from '@envive-ai/react-toolkit-v3/WidgetWrapper';\nimport { ColorNames } from '../application/models/colorsConfigV3';\nimport { CustomerServiceType } from '../types/customerService';\nimport type { SearchConfig } from './types';\n\nexport enum LetterSpacingCSSVar {\n  T1 = 'envive-typography-letter-spacing-t1',\n  T2 = 'envive-typography-letter-spacing-t2',\n  T3 = 'envive-typography-letter-spacing-t3',\n  H1 = 'envive-typography-letter-spacing-h1',\n  H2 = 'envive-typography-letter-spacing-h2',\n  H3 = 'envive-typography-letter-spacing-h3',\n  B1 = 'envive-typography-letter-spacing-b1',\n  B2 = 'envive-typography-letter-spacing-b2',\n  B3 = 'envive-typography-letter-spacing-b3',\n  B4 = 'envive-typography-letter-spacing-b4',\n  B5 = 'envive-typography-letter-spacing-b5',\n  L1 = 'envive-typography-letter-spacing-l1',\n  L2 = 'envive-typography-letter-spacing-l2',\n}\n\nexport enum LineHeightCSSVar {\n  T1 = 'envive-typography-line-height-t1',\n  T2 = 'envive-typography-line-height-t2',\n  T3 = 'envive-typography-line-height-t3',\n  H1 = 'envive-typography-line-height-h1',\n  H2 = 'envive-typography-line-height-h2',\n  H3 = 'envive-typography-line-height-h3',\n  B1 = 'envive-typography-line-height-b1',\n  B2 = 'envive-typography-line-height-b2',\n  B3 = 'envive-typography-line-height-b3',\n  B4 = 'envive-typography-line-height-b4',\n  B5 = 'envive-typography-line-height-b5',\n  L1 = 'envive-typography-line-height-l1',\n  L2 = 'envive-typography-line-height-l2',\n}\n\nexport enum FontWeightCSSVar {\n  Title = 'envive-typography-font-weight-title',\n  Header = 'envive-typography-font-weight-header',\n  BodyEmphasis = 'envive-typography-font-weight-body-emphasis',\n  BodyStandard = 'envive-typography-font-weight-body-standard',\n}\n\nexport enum FontSizeCSSVar {\n  T1 = 'envive-typography-font-size-t1',\n  T2 = 'envive-typography-font-size-t2',\n  T3 = 'envive-typography-font-size-t3',\n  H1 = 'envive-typography-font-size-h1',\n  H2 = 'envive-typography-font-size-h2',\n  H3 = 'envive-typography-font-size-h3',\n  B1 = 'envive-typography-font-size-b1',\n  B2 = 'envive-typography-font-size-b2',\n  B3 = 'envive-typography-font-size-b3',\n  B4 = 'envive-typography-font-size-b4',\n  B5 = 'envive-typography-font-size-b5',\n  L1 = 'envive-typography-font-size-l1',\n  L2 = 'envive-typography-font-size-l2',\n}\n\nexport enum FontFamilyCSSVar {\n  Title = 'envive-typography-font-family-title',\n  Header = 'envive-typography-font-family-header',\n  Body = 'envive-typography-font-family-body',\n}\n\nexport enum ThemeCSSVar {\n  GlobalCustom = 'envive-global-custom-theme',\n}\n\nexport enum AspectRatioCSSVar {\n  GlobalCustom = 'envive-global-custom-aspect-ratio',\n}\n\nexport enum BorderRadiusCSSVar {\n  GlobalCustom = 'envive-global-custom-border-radius',\n}\n\nexport const enum ColorsNamesVars {\n  TextPrimary = `envive-colors-${ColorNames.TextPrimary}`,\n  TextSecondary = `envive-colors-${ColorNames.TextSecondary}`,\n  TextAccent = `envive-colors-${ColorNames.TextAccent}`,\n  TextLink = `envive-colors-${ColorNames.TextLink}`,\n  TextLight = `envive-colors-${ColorNames.TextLight}`,\n  BackgroundPrimary = `envive-colors-${ColorNames.BackgroundPrimary}`,\n  BackgroundSecondary = `envive-colors-${ColorNames.BackgroundSecondary}`,\n  BackgroundTertiary = `envive-colors-${ColorNames.BackgroundTertiary}`,\n  BackgroundDark = `envive-colors-${ColorNames.BackgroundDark}`,\n  BackgroundLight = `envive-colors-${ColorNames.BackgroundLight}`,\n  BorderLight = `envive-colors-${ColorNames.BorderLight}`,\n  BorderMedium = `envive-colors-${ColorNames.BorderMedium}`,\n  BorderDark = `envive-colors-${ColorNames.BorderDark}`,\n  AccentPrimary = `envive-colors-${ColorNames.AccentPrimary}`,\n  AccentSecondary = `envive-colors-${ColorNames.AccentSecondary}`,\n}\n\nexport const enum ButtonColorsVars {\n  LightButtonBackgroundColor = 'envive-colors-button-light-background-color',\n  LightButtonIconColor = 'envive-colors-button-light-icon-color',\n  DarkButtonBackgroundColor = 'envive-colors-button-dark-background-color',\n  DarkButtonIconColor = 'envive-colors-button-dark-icon-color',\n}\n\ntype ImageAspectRatio = '1/1' | '3/4';\n\ntype ButtonColors = {\n  lightButtonBackgroundColor: string;\n  lightButtonIconColor: string;\n  darkButtonBackgroundColor: string;\n  darkButtonIconColor: string;\n};\n\n// TODO: Set default values for the typography configs\ntype Typography = {\n  titleFontFamily: string;\n  headerFontFamily: string;\n  bodyFontFamily: string;\n\n  fontSize?: {\n    t1: string;\n    t2: string;\n    t3: string;\n    h1: string;\n    h2: string;\n    h3: string;\n    b1: string;\n    b2: string;\n    b3: string;\n    b4: string;\n    b5: string;\n    l1: string;\n    l2: string;\n  };\n\n  fontWeight?: {\n    title: string;\n    header: string;\n    bodyEmphasis: string;\n    bodyStandard: string;\n  };\n\n  letterSpacing?: {\n    t1: string;\n    t2: string;\n    t3: string;\n    h1: string;\n    h2: string;\n    h3: string;\n    b1: string;\n    b2: string;\n    b3: string;\n    b4: string;\n    b5: string;\n    l1: string;\n    l2: string;\n  };\n\n  lineHeight?: {\n    t1: number;\n    t2: number;\n    t3: number;\n    h1: number;\n    h2: number;\n    h3: number;\n    b1: number;\n    b2: number;\n    b3: number;\n    b4: number;\n    b5: number;\n    l1: number;\n    l2: number;\n  };\n};\n\ntype LookAndFeelConfig = {\n  theme: Theme;\n  agentName: string;\n  chatHeaderLogoDarkSrc: string;\n  chatHeaderLogoLightSrc: string;\n  widgetLogoSrc: string;\n  hideWidgetLogo: boolean;\n  voiceInputEnabled?: boolean;\n  elementRadius: number;\n  imageAspectRatio: ImageAspectRatio;\n  buttonColors: ButtonColors;\n  typography: Typography;\n};\n\nexport enum ConfigVersionEnum {\n  V3 = 'v3',\n  Deprecated = 'deprecated',\n}\n\ntype ConfigVersion = ConfigVersionEnum.V3 | ConfigVersionEnum.Deprecated | undefined;\n\ntype Mode = 'dark' | 'light';\n\ntype ShowOptions = 'always' | 'postInteraction' | 'none';\n\ntype Style = 'attached' | 'detached';\n\ntype FloatingButtonConfig = {\n  position: FloatingButtonLocation;\n  backgroundColor?: string;\n  mode: Mode;\n  showOption: ShowOptions;\n  iconSVGSrc?: string;\n  style: Style;\n};\n\nexport type ReferrerPopupTrigger = {\n  type: 'referrer';\n  referrers: string[];\n};\n\nexport type AutomaticPopupTrigger = {\n  type: 'automatic';\n};\nexport type PopupTrigger = ReferrerPopupTrigger | AutomaticPopupTrigger;\nexport type AutoPopupTrigger = {\n  delay: number;\n  trigger: PopupTrigger;\n};\nexport interface AutoPopupConfig {\n  triggers: AutoPopupTrigger[];\n}\n\ntype FloatingChatConfig = {\n  headerBackgroundColor?: string;\n  headerMode: Mode;\n  welcomeMessageIconColor: SparkleIconColor;\n  showVerifiedBuyer: boolean;\n  userQueryInputEnabled: boolean;\n  showEnviveLogo: boolean;\n  ignoreFirstModelResponse?: boolean;\n  neverShowSingleProductCards?: boolean;\n  welcomeMessageTitle: string;\n  welcomeMessageText: string;\n  chatFooterTextFieldPlaceholderText: string;\n  autoPopupConfig?: AutoPopupConfig;\n};\n\ntype CustomerServiceIntegration = {\n  enabled: boolean;\n  provider: CustomerServiceType;\n  suppressMerchantButton?: boolean;\n};\n\ntype SPASettings = {\n  enabled: boolean;\n  refreshInterval?: number;\n};\n\ntype OrgUIConfigV3 = {\n  id?: string;\n\n  version: ConfigVersion;\n\n  shortName: string;\n\n  lookAndFeel: LookAndFeelConfig;\n\n  floatingButton: FloatingButtonConfig;\n\n  floatingChat: FloatingChatConfig;\n\n  merchantOverrideCss?: string;\n\n  customerServiceIntegration?: CustomerServiceIntegration;\n\n  singlePageApplicationSettings?: SPASettings;\n\n  searchConfig?: SearchConfig;\n};\n\nexport enum WidgetTypeV3 {\n  PromptCarouselV3 = 'PromptCarouselV3',\n  TitledPromptCarouselV3 = 'TitledPromptCarouselV3',\n  SocialProofV3 = 'SocialProofV3',\n  TypingAnimationV3 = 'TypingAnimationV3',\n  ChatPreviewV3 = 'ChatPreviewV3',\n  ChatPreviewComparisonV3 = 'ChatPreviewComparisonV3',\n  ChatPreviewLoadingV3 = 'ChatPreviewLoadingV3',\n  ImagePromptCardV3 = 'ImagePromptCardV3',\n  PromptButtonCarouselWithImageV3 = 'PromptButtonCarouselWithImageV3',\n  ImageBannerV3 = 'ImageBannerV3',\n  SingleImagePromptV3 = 'SingleImagePromptV3',\n  FloatingChatV3 = 'FloatingChatV3',\n  FloatingButtonV3 = 'FloatingButtonV3',\n  ProductCardV3 = 'ProductCardV3',\n  FullPageSalesAgentV3 = 'FullPageSalesAgentV3',\n}\n\ninterface BaseWidgetConfig<T extends WidgetTypeV3> {\n  widgetConfigId: string;\n  type: T;\n  contentId?: string; // Widget ID\n}\n\ninterface PromptCarouselWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.PromptCarouselV3> {\n  promptButtonType?: PromptButtonVariant;\n  boldFirstButton?: boolean;\n  promptCarouselRows?: PromptCarouselRows;\n  animationSpeed?: AnimationSpeed;\n}\n\ninterface TitledPromptCarouselWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.TitledPromptCarouselV3> {\n  promptButtonType?: PromptButtonVariant;\n  boldFirstButton?: boolean;\n  promptCarouselRows?: PromptCarouselRows;\n  animationSpeed?: AnimationSpeed;\n}\ninterface SocialProofWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.SocialProofV3> {\n  kind: WidgetKind;\n  variant: WidgetWrapperVariant;\n  hexCardColor?: string;\n  promptCarouselRows: PromptCarouselRows;\n  hideImage?: boolean;\n  imageGalleryLayout: Exclude<ImageGalleryLayout, 'TWO_SIDE'>;\n  hideTextField?: boolean;\n  primaryButtonVariant: Exclude<PromptButtonVariant, 'suggestedResponse' | 'ghost'>;\n  secondaryButtonVariant: Exclude<PromptButtonVariant, 'suggestedResponse' | 'ghost'>;\n  dynamicLayout?: DynamicLayout;\n  images?: ImageGalleryImage[];\n}\n\ninterface TypingAnimationWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.TypingAnimationV3> {\n  widgetVariant?: WidgetWrapperVariant;\n  cardColor?: string;\n  promptButtonType?: PromptButtonVariant;\n  promptCarouselRows?: PromptCarouselRows;\n  showTextField?: boolean;\n}\n\ninterface ChatPreviewComparisonWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.ChatPreviewComparisonV3> {\n  variant: WidgetWrapperVariant;\n  hexCardColor?: string;\n  hideImage?: boolean;\n  hideTextField?: boolean;\n}\n\ninterface ChatPreviewLoadingWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.ChatPreviewLoadingV3> {\n  variant: WidgetWrapperVariant;\n  hexCardColor?: string;\n  hideTextField?: boolean;\n}\n\ninterface ChatPreviewWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.ChatPreviewV3> {\n  variant: WidgetWrapperVariant;\n  hexCardColor?: string;\n  hideTextField?: boolean;\n}\n\ninterface PromptButtonCarouselWithImageWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.PromptButtonCarouselWithImageV3> {\n  promptButtonType?: PromptButtonVariant;\n  image?: ImageGalleryImage;\n  hideTextField?: boolean;\n  isDynamic?: boolean;\n}\n\ninterface FloatingChatWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.FloatingChatV3> {}\n\ninterface ProductCardWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.ProductCardV3> {\n  promptButtonType?: PromptButtonVariant;\n  italicizeHeadline?: boolean;\n  fallbackColor?: string;\n  imageSrc?: string;\n  mode?: Mode;\n}\n\ninterface FullPageSalesAgentWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.FullPageSalesAgentV3> {\n  headerContainer?: string;\n  autoHeight?: boolean;\n  sparkleColor?: string;\n  useBackgroundImage?: boolean;\n  mobileBackgroundImage?: string;\n  desktopBackgroundImage?: string;\n  backgroundColor?: string;\n  suggestionButtonType?: PromptButtonVariant;\n}\n\ntype WidgetConfigV3 =\n  | PromptCarouselWidgetV3Config\n  | SocialProofWidgetV3Config\n  | TitledPromptCarouselWidgetV3Config\n  | ChatPreviewComparisonWidgetV3Config\n  | ChatPreviewLoadingWidgetV3Config\n  | TypingAnimationWidgetV3Config\n  | ChatPreviewWidgetV3Config\n  | PromptButtonCarouselWithImageWidgetV3Config\n  | FloatingChatWidgetV3Config\n  | ProductCardWidgetV3Config\n  | FullPageSalesAgentWidgetV3Config;\n\nexport type {\n  ChatPreviewComparisonWidgetV3Config,\n  ChatPreviewLoadingWidgetV3Config,\n  ChatPreviewWidgetV3Config,\n  CustomerServiceIntegration,\n  FloatingButtonConfig,\n  FloatingChatConfig,\n  FloatingChatWidgetV3Config,\n  FullPageSalesAgentWidgetV3Config,\n  LookAndFeelConfig,\n  OrgUIConfigV3,\n  ProductCardWidgetV3Config,\n  PromptButtonCarouselWithImageWidgetV3Config,\n  PromptCarouselWidgetV3Config,\n  SocialProofWidgetV3Config,\n  SPASettings,\n  TitledPromptCarouselWidgetV3Config,\n  TypingAnimationWidgetV3Config,\n  WidgetConfigV3,\n};\n"],"mappings":";;;AAYA,IAAY,sEAAL;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGF,IAAY,gEAAL;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGF,IAAY,gEAAL;AACL;AACA;AACA;AACA;;;AAGF,IAAY,4DAAL;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGF,IAAY,gEAAL;AACL;AACA;AACA;;;AAGF,IAAY,sDAAL;AACL;;;AAGF,IAAY,kEAAL;AACL;;;AAGF,IAAY,oEAAL;AACL;;;AAGF,IAAkB,8DAAX;AACL,oCAAc,iBAAiB,WAAW;AAC1C,sCAAgB,iBAAiB,WAAW;AAC5C,mCAAa,iBAAiB,WAAW;AACzC,iCAAW,iBAAiB,WAAW;AACvC,kCAAY,iBAAiB,WAAW;AACxC,0CAAoB,iBAAiB,WAAW;AAChD,4CAAsB,iBAAiB,WAAW;AAClD,2CAAqB,iBAAiB,WAAW;AACjD,uCAAiB,iBAAiB,WAAW;AAC7C,wCAAkB,iBAAiB,WAAW;AAC9C,oCAAc,iBAAiB,WAAW;AAC1C,qCAAe,iBAAiB,WAAW;AAC3C,mCAAa,iBAAiB,WAAW;AACzC,sCAAgB,iBAAiB,WAAW;AAC5C,wCAAkB,iBAAiB,WAAW;;;AAGhD,IAAkB,gEAAX;AACL;AACA;AACA;AACA;;;AAwFF,IAAY,kEAAL;AACL;AACA;;;AAqFF,IAAY,wDAAL;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"typesV3.js","names":[],"sources":["../../src/contexts/typesV3.ts"],"sourcesContent":["import { FloatingButtonLocation } from '@envive-ai/react-toolkit-v3/FloatingButton';\nimport { ImageGalleryImage, ImageGalleryLayout } from '@envive-ai/react-toolkit-v3/ImageGallery';\nimport { PromptButtonVariant } from '@envive-ai/react-toolkit-v3/PromptButton';\nimport { AnimationSpeed, PromptCarouselRows } from '@envive-ai/react-toolkit-v3/PromptCarousel';\nimport { DynamicLayout, WidgetKind } from '@envive-ai/react-toolkit-v3/SocialProof';\nimport { Theme } from '@envive-ai/react-toolkit-v3/Tokens';\nimport { SparkleIconColor } from '@envive-ai/react-toolkit-v3/WelcomeMessage';\nimport { WidgetWrapperVariant } from '@envive-ai/react-toolkit-v3/WidgetWrapper';\nimport { ColorNames } from '../application/models/colorsConfigV3';\nimport { CustomerServiceType } from '../types/customerService';\nimport type { SearchConfig } from './types';\n\nexport enum LetterSpacingCSSVar {\n  T1 = 'envive-typography-letter-spacing-t1',\n  T2 = 'envive-typography-letter-spacing-t2',\n  T3 = 'envive-typography-letter-spacing-t3',\n  H1 = 'envive-typography-letter-spacing-h1',\n  H2 = 'envive-typography-letter-spacing-h2',\n  H3 = 'envive-typography-letter-spacing-h3',\n  B1 = 'envive-typography-letter-spacing-b1',\n  B2 = 'envive-typography-letter-spacing-b2',\n  B3 = 'envive-typography-letter-spacing-b3',\n  B4 = 'envive-typography-letter-spacing-b4',\n  B5 = 'envive-typography-letter-spacing-b5',\n  L1 = 'envive-typography-letter-spacing-l1',\n  L2 = 'envive-typography-letter-spacing-l2',\n}\n\nexport enum LineHeightCSSVar {\n  T1 = 'envive-typography-line-height-t1',\n  T2 = 'envive-typography-line-height-t2',\n  T3 = 'envive-typography-line-height-t3',\n  H1 = 'envive-typography-line-height-h1',\n  H2 = 'envive-typography-line-height-h2',\n  H3 = 'envive-typography-line-height-h3',\n  B1 = 'envive-typography-line-height-b1',\n  B2 = 'envive-typography-line-height-b2',\n  B3 = 'envive-typography-line-height-b3',\n  B4 = 'envive-typography-line-height-b4',\n  B5 = 'envive-typography-line-height-b5',\n  L1 = 'envive-typography-line-height-l1',\n  L2 = 'envive-typography-line-height-l2',\n}\n\nexport enum FontWeightCSSVar {\n  Title = 'envive-typography-font-weight-title',\n  Header = 'envive-typography-font-weight-header',\n  BodyEmphasis = 'envive-typography-font-weight-body-emphasis',\n  BodyStandard = 'envive-typography-font-weight-body-standard',\n}\n\nexport enum FontSizeCSSVar {\n  T1 = 'envive-typography-font-size-t1',\n  T2 = 'envive-typography-font-size-t2',\n  T3 = 'envive-typography-font-size-t3',\n  H1 = 'envive-typography-font-size-h1',\n  H2 = 'envive-typography-font-size-h2',\n  H3 = 'envive-typography-font-size-h3',\n  B1 = 'envive-typography-font-size-b1',\n  B2 = 'envive-typography-font-size-b2',\n  B3 = 'envive-typography-font-size-b3',\n  B4 = 'envive-typography-font-size-b4',\n  B5 = 'envive-typography-font-size-b5',\n  L1 = 'envive-typography-font-size-l1',\n  L2 = 'envive-typography-font-size-l2',\n}\n\nexport enum FontFamilyCSSVar {\n  Title = 'envive-typography-font-family-title',\n  Header = 'envive-typography-font-family-header',\n  Body = 'envive-typography-font-family-body',\n}\n\nexport enum ThemeCSSVar {\n  GlobalCustom = 'envive-global-custom-theme',\n}\n\nexport enum AspectRatioCSSVar {\n  GlobalCustom = 'envive-global-custom-aspect-ratio',\n}\n\nexport enum BorderRadiusCSSVar {\n  GlobalCustom = 'envive-global-custom-border-radius',\n}\n\nexport const enum ColorsNamesVars {\n  TextPrimary = `envive-colors-${ColorNames.TextPrimary}`,\n  TextSecondary = `envive-colors-${ColorNames.TextSecondary}`,\n  TextAccent = `envive-colors-${ColorNames.TextAccent}`,\n  TextLink = `envive-colors-${ColorNames.TextLink}`,\n  TextLight = `envive-colors-${ColorNames.TextLight}`,\n  BackgroundPrimary = `envive-colors-${ColorNames.BackgroundPrimary}`,\n  BackgroundSecondary = `envive-colors-${ColorNames.BackgroundSecondary}`,\n  BackgroundTertiary = `envive-colors-${ColorNames.BackgroundTertiary}`,\n  BackgroundDark = `envive-colors-${ColorNames.BackgroundDark}`,\n  BackgroundLight = `envive-colors-${ColorNames.BackgroundLight}`,\n  BorderLight = `envive-colors-${ColorNames.BorderLight}`,\n  BorderMedium = `envive-colors-${ColorNames.BorderMedium}`,\n  BorderDark = `envive-colors-${ColorNames.BorderDark}`,\n  AccentPrimary = `envive-colors-${ColorNames.AccentPrimary}`,\n  AccentSecondary = `envive-colors-${ColorNames.AccentSecondary}`,\n}\n\nexport const enum ButtonColorsVars {\n  LightButtonBackgroundColor = 'envive-colors-button-light-background-color',\n  LightButtonBorderColor = 'envive-colors-button-light-border-color',\n  LightButtonIconColor = 'envive-colors-button-light-icon-color',\n  DarkButtonBackgroundColor = 'envive-colors-button-dark-background-color',\n  DarkButtonIconColor = 'envive-colors-button-dark-icon-color',\n}\n\ntype ImageAspectRatio = '1/1' | '3/4';\n\ntype ButtonColors = {\n  lightButtonBackgroundColor: string;\n  lightButtonBorderColor?: string;\n  lightButtonIconColor: string;\n  darkButtonBackgroundColor: string;\n  darkButtonIconColor: string;\n};\n\n// TODO: Set default values for the typography configs\ntype Typography = {\n  titleFontFamily: string;\n  headerFontFamily: string;\n  bodyFontFamily: string;\n\n  fontSize?: {\n    t1: string;\n    t2: string;\n    t3: string;\n    h1: string;\n    h2: string;\n    h3: string;\n    b1: string;\n    b2: string;\n    b3: string;\n    b4: string;\n    b5: string;\n    l1: string;\n    l2: string;\n  };\n\n  fontWeight?: {\n    title: string;\n    header: string;\n    bodyEmphasis: string;\n    bodyStandard: string;\n  };\n\n  letterSpacing?: {\n    t1: string;\n    t2: string;\n    t3: string;\n    h1: string;\n    h2: string;\n    h3: string;\n    b1: string;\n    b2: string;\n    b3: string;\n    b4: string;\n    b5: string;\n    l1: string;\n    l2: string;\n  };\n\n  lineHeight?: {\n    t1: number;\n    t2: number;\n    t3: number;\n    h1: number;\n    h2: number;\n    h3: number;\n    b1: number;\n    b2: number;\n    b3: number;\n    b4: number;\n    b5: number;\n    l1: number;\n    l2: number;\n  };\n};\n\ntype LookAndFeelConfig = {\n  theme: Theme;\n  agentName: string;\n  chatHeaderLogoDarkSrc: string;\n  chatHeaderLogoLightSrc: string;\n  widgetLogoSrc: string;\n  hideWidgetLogo: boolean;\n  voiceInputEnabled?: boolean;\n  elementRadius: number;\n  imageAspectRatio: ImageAspectRatio;\n  buttonColors: ButtonColors;\n  typography: Typography;\n};\n\nexport enum ConfigVersionEnum {\n  V3 = 'v3',\n  Deprecated = 'deprecated',\n}\n\ntype ConfigVersion = ConfigVersionEnum.V3 | ConfigVersionEnum.Deprecated | undefined;\n\ntype Mode = 'dark' | 'light';\n\ntype ShowOptions = 'always' | 'postInteraction' | 'none';\n\ntype Style = 'attached' | 'detached';\n\ntype FloatingButtonConfig = {\n  position: FloatingButtonLocation;\n  backgroundColor?: string;\n  mode: Mode;\n  showOption: ShowOptions;\n  iconSVGSrc?: string;\n  style: Style;\n};\n\nexport type ReferrerPopupTrigger = {\n  type: 'referrer';\n  referrers: string[];\n};\n\nexport type AutomaticPopupTrigger = {\n  type: 'automatic';\n};\nexport type PopupTrigger = ReferrerPopupTrigger | AutomaticPopupTrigger;\nexport type AutoPopupTrigger = {\n  delay: number;\n  trigger: PopupTrigger;\n};\nexport interface AutoPopupConfig {\n  triggers: AutoPopupTrigger[];\n}\n\ntype FloatingChatConfig = {\n  headerBackgroundColor?: string;\n  headerMode: Mode;\n  welcomeMessageIconColor: SparkleIconColor;\n  showVerifiedBuyer: boolean;\n  userQueryInputEnabled: boolean;\n  showEnviveLogo: boolean;\n  ignoreFirstModelResponse?: boolean;\n  neverShowSingleProductCards?: boolean;\n  welcomeMessageTitle: string;\n  welcomeMessageText: string;\n  chatFooterTextFieldPlaceholderText: string;\n  autoPopupConfig?: AutoPopupConfig;\n};\n\ntype CustomerServiceIntegration = {\n  enabled: boolean;\n  provider: CustomerServiceType;\n  suppressMerchantButton?: boolean;\n};\n\ntype SPASettings = {\n  enabled: boolean;\n  refreshInterval?: number;\n};\n\ntype OrgUIConfigV3 = {\n  id?: string;\n\n  version: ConfigVersion;\n\n  shortName: string;\n\n  lookAndFeel: LookAndFeelConfig;\n\n  floatingButton: FloatingButtonConfig;\n\n  floatingChat: FloatingChatConfig;\n\n  merchantOverrideCss?: string;\n\n  customerServiceIntegration?: CustomerServiceIntegration;\n\n  singlePageApplicationSettings?: SPASettings;\n\n  searchConfig?: SearchConfig;\n};\n\nexport enum WidgetTypeV3 {\n  PromptCarouselV3 = 'PromptCarouselV3',\n  TitledPromptCarouselV3 = 'TitledPromptCarouselV3',\n  SocialProofV3 = 'SocialProofV3',\n  TypingAnimationV3 = 'TypingAnimationV3',\n  ChatPreviewV3 = 'ChatPreviewV3',\n  ChatPreviewComparisonV3 = 'ChatPreviewComparisonV3',\n  ChatPreviewLoadingV3 = 'ChatPreviewLoadingV3',\n  ImagePromptCardV3 = 'ImagePromptCardV3',\n  PromptButtonCarouselWithImageV3 = 'PromptButtonCarouselWithImageV3',\n  ImageBannerV3 = 'ImageBannerV3',\n  SingleImagePromptV3 = 'SingleImagePromptV3',\n  FloatingChatV3 = 'FloatingChatV3',\n  FloatingButtonV3 = 'FloatingButtonV3',\n  ProductCardV3 = 'ProductCardV3',\n  FullPageSalesAgentV3 = 'FullPageSalesAgentV3',\n}\n\ninterface BaseWidgetConfig<T extends WidgetTypeV3> {\n  widgetConfigId: string;\n  type: T;\n  contentId?: string; // Widget ID\n}\n\ninterface PromptCarouselWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.PromptCarouselV3> {\n  promptButtonType?: PromptButtonVariant;\n  boldFirstButton?: boolean;\n  promptCarouselRows?: PromptCarouselRows;\n  animationSpeed?: AnimationSpeed;\n}\n\ninterface TitledPromptCarouselWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.TitledPromptCarouselV3> {\n  promptButtonType?: PromptButtonVariant;\n  boldFirstButton?: boolean;\n  promptCarouselRows?: PromptCarouselRows;\n  animationSpeed?: AnimationSpeed;\n}\ninterface SocialProofWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.SocialProofV3> {\n  kind: WidgetKind;\n  variant: WidgetWrapperVariant;\n  hexCardColor?: string;\n  promptCarouselRows: PromptCarouselRows;\n  hideImage?: boolean;\n  imageGalleryLayout: Exclude<ImageGalleryLayout, 'TWO_SIDE'>;\n  hideTextField?: boolean;\n  primaryButtonVariant: Exclude<PromptButtonVariant, 'suggestedResponse' | 'ghost'>;\n  secondaryButtonVariant: Exclude<PromptButtonVariant, 'suggestedResponse' | 'ghost'>;\n  dynamicLayout?: DynamicLayout;\n  images?: ImageGalleryImage[];\n}\n\ninterface TypingAnimationWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.TypingAnimationV3> {\n  widgetVariant?: WidgetWrapperVariant;\n  cardColor?: string;\n  promptButtonType?: PromptButtonVariant;\n  promptCarouselRows?: PromptCarouselRows;\n  showTextField?: boolean;\n}\n\ninterface ChatPreviewComparisonWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.ChatPreviewComparisonV3> {\n  variant: WidgetWrapperVariant;\n  hexCardColor?: string;\n  hideImage?: boolean;\n  hideTextField?: boolean;\n}\n\ninterface ChatPreviewLoadingWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.ChatPreviewLoadingV3> {\n  variant: WidgetWrapperVariant;\n  hexCardColor?: string;\n  hideTextField?: boolean;\n}\n\ninterface ChatPreviewWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.ChatPreviewV3> {\n  variant: WidgetWrapperVariant;\n  hexCardColor?: string;\n  hideTextField?: boolean;\n}\n\ninterface PromptButtonCarouselWithImageWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.PromptButtonCarouselWithImageV3> {\n  promptButtonType?: PromptButtonVariant;\n  image?: ImageGalleryImage;\n  hideTextField?: boolean;\n  isDynamic?: boolean;\n}\n\ninterface FloatingChatWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.FloatingChatV3> {}\n\ninterface ProductCardWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.ProductCardV3> {\n  promptButtonType?: PromptButtonVariant;\n  italicizeHeadline?: boolean;\n  fallbackColor?: string;\n  imageSrc?: string;\n  mode?: Mode;\n}\n\ninterface FullPageSalesAgentWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3.FullPageSalesAgentV3> {\n  headerContainer?: string;\n  autoHeight?: boolean;\n  sparkleColor?: string;\n  useBackgroundImage?: boolean;\n  mobileBackgroundImage?: string;\n  desktopBackgroundImage?: string;\n  backgroundColor?: string;\n  suggestionButtonType?: PromptButtonVariant;\n}\n\ntype WidgetConfigV3 =\n  | PromptCarouselWidgetV3Config\n  | SocialProofWidgetV3Config\n  | TitledPromptCarouselWidgetV3Config\n  | ChatPreviewComparisonWidgetV3Config\n  | ChatPreviewLoadingWidgetV3Config\n  | TypingAnimationWidgetV3Config\n  | ChatPreviewWidgetV3Config\n  | PromptButtonCarouselWithImageWidgetV3Config\n  | FloatingChatWidgetV3Config\n  | ProductCardWidgetV3Config\n  | FullPageSalesAgentWidgetV3Config;\n\nexport type {\n  ChatPreviewComparisonWidgetV3Config,\n  ChatPreviewLoadingWidgetV3Config,\n  ChatPreviewWidgetV3Config,\n  CustomerServiceIntegration,\n  FloatingButtonConfig,\n  FloatingChatConfig,\n  FloatingChatWidgetV3Config,\n  FullPageSalesAgentWidgetV3Config,\n  LookAndFeelConfig,\n  OrgUIConfigV3,\n  ProductCardWidgetV3Config,\n  PromptButtonCarouselWithImageWidgetV3Config,\n  PromptCarouselWidgetV3Config,\n  SocialProofWidgetV3Config,\n  SPASettings,\n  TitledPromptCarouselWidgetV3Config,\n  TypingAnimationWidgetV3Config,\n  WidgetConfigV3,\n};\n"],"mappings":";;;AAYA,IAAY,sEAAL;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGF,IAAY,gEAAL;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGF,IAAY,gEAAL;AACL;AACA;AACA;AACA;;;AAGF,IAAY,4DAAL;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGF,IAAY,gEAAL;AACL;AACA;AACA;;;AAGF,IAAY,sDAAL;AACL;;;AAGF,IAAY,kEAAL;AACL;;;AAGF,IAAY,oEAAL;AACL;;;AAGF,IAAkB,8DAAX;AACL,oCAAc,iBAAiB,WAAW;AAC1C,sCAAgB,iBAAiB,WAAW;AAC5C,mCAAa,iBAAiB,WAAW;AACzC,iCAAW,iBAAiB,WAAW;AACvC,kCAAY,iBAAiB,WAAW;AACxC,0CAAoB,iBAAiB,WAAW;AAChD,4CAAsB,iBAAiB,WAAW;AAClD,2CAAqB,iBAAiB,WAAW;AACjD,uCAAiB,iBAAiB,WAAW;AAC7C,wCAAkB,iBAAiB,WAAW;AAC9C,oCAAc,iBAAiB,WAAW;AAC1C,qCAAe,iBAAiB,WAAW;AAC3C,mCAAa,iBAAiB,WAAW;AACzC,sCAAgB,iBAAiB,WAAW;AAC5C,wCAAkB,iBAAiB,WAAW;;;AAGhD,IAAkB,gEAAX;AACL;AACA;AACA;AACA;AACA;;;AAyFF,IAAY,kEAAL;AACL;AACA;;;AAqFF,IAAY,wDAAL;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA"}

package/dist/hooks/FocusTrap/index.cjs

@@ -0,0 +1,3 @@
+const require_useFocusTrap = require('./useFocusTrap.cjs');
+
+exports.useFocusTrap = require_useFocusTrap.useFocusTrap;

package/dist/hooks/FocusTrap/index.d.cts

@@ -0,0 +1,2 @@
+import { useFocusTrap } from "./useFocusTrap.cjs";
+export { useFocusTrap };

package/dist/hooks/FocusTrap/index.d.ts

@@ -0,0 +1,2 @@
+import { useFocusTrap } from "./useFocusTrap.js";
+export { useFocusTrap };

package/dist/hooks/FocusTrap/index.js

@@ -0,0 +1,3 @@
+import { useFocusTrap } from "./useFocusTrap.js";
+
+export { useFocusTrap };

package/dist/hooks/FocusTrap/useFocusTrap.cjs

@@ -0,0 +1,105 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+let react = require("react");
+
+//#region src/hooks/FocusTrap/useFocusTrap.ts
+const FOCUSABLE_SELECTOR = [
+	"a[href]",
+	"button:not([disabled])",
+	"input:not([disabled]):not([type=\"hidden\"])",
+	"textarea:not([disabled])",
+	"select:not([disabled])",
+	"[tabindex]:not([tabindex=\"-1\"])"
+].join(",");
+const isElementVisible = (el) => {
+	if (el.hasAttribute("hidden")) return false;
+	if (typeof window === "undefined") return true;
+	const style = window.getComputedStyle(el);
+	return style.display !== "none" && style.visibility !== "hidden";
+};
+const getFocusableElements = (container) => Array.from(container.querySelectorAll(FOCUSABLE_SELECTOR)).filter(isElementVisible);
+/**
+* Returns the deepest active element across (possibly nested) shadow roots,
+* starting from the document. Plain `document.activeElement` returns the shadow
+* host when focus is inside an open shadow root, so we recurse into shadowRoot
+* to find the truly focused element.
+*/
+const getDeepActiveElement = () => {
+	if (typeof document === "undefined") return null;
+	let active = document.activeElement;
+	while (active && active.shadowRoot && active.shadowRoot.activeElement) active = active.shadowRoot.activeElement;
+	return active;
+};
+/**
+* Trap keyboard focus inside `containerRef` while `enabled` is true.
+*
+* On enable: moves focus to the first focusable element inside the container.
+* If the container is empty (e.g. lazy-loaded content), waits for DOM mutations
+* and focuses the first focusable as soon as it appears.
+*
+* While enabled: Tab and Shift+Tab wrap around so focus stays inside.
+*
+* On disable: restores focus to the previously focused element if it is still
+* present in the document.
+*/
+const useFocusTrap = (containerRef, enabled) => {
+	(0, react.useEffect)(() => {
+		if (!enabled || typeof document === "undefined") return void 0;
+		const container = containerRef.current;
+		if (!container) return void 0;
+		const root = container.getRootNode();
+		const previouslyFocused = getDeepActiveElement();
+		const getActiveElement = () => root.activeElement;
+		const focusFirst = () => {
+			const first = getFocusableElements(container)[0];
+			if (first) {
+				first.focus();
+				return true;
+			}
+			return false;
+		};
+		let observer = null;
+		if (!focusFirst()) {
+			observer = new MutationObserver(() => {
+				if (focusFirst()) {
+					observer?.disconnect();
+					observer = null;
+				}
+			});
+			observer.observe(container, {
+				childList: true,
+				subtree: true
+			});
+		}
+		const handleKeyDown = (e) => {
+			if (e.key !== "Tab") return;
+			const focusables = getFocusableElements(container);
+			if (focusables.length === 0) {
+				e.preventDefault();
+				return;
+			}
+			const first = focusables[0];
+			const last = focusables[focusables.length - 1];
+			const active = getActiveElement();
+			const isInsideContainer = active ? container.contains(active) : false;
+			if (e.shiftKey) {
+				if (active === first || !isInsideContainer) {
+					e.preventDefault();
+					last.focus();
+				}
+			} else if (active === last || !isInsideContainer) {
+				e.preventDefault();
+				first.focus();
+			}
+		};
+		container.addEventListener("keydown", handleKeyDown);
+		return () => {
+			observer?.disconnect();
+			container.removeEventListener("keydown", handleKeyDown);
+			if (previouslyFocused && typeof previouslyFocused.focus === "function" && previouslyFocused.isConnected) previouslyFocused.focus();
+		};
+	}, [enabled, containerRef]);
+};
+
+//#endregion
+exports.useFocusTrap = useFocusTrap;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"useFocusTrap.cjs","names":["observer: MutationObserver | null"],"sources":["../../../src/hooks/FocusTrap/useFocusTrap.ts"],"sourcesContent":["import { RefObject, useEffect } from 'react';\n\nconst FOCUSABLE_SELECTOR = [\n  'a[href]',\n  'button:not([disabled])',\n  'input:not([disabled]):not([type=\"hidden\"])',\n  'textarea:not([disabled])',\n  'select:not([disabled])',\n  '[tabindex]:not([tabindex=\"-1\"])',\n].join(',');\n\nconst isElementVisible = (el: HTMLElement): boolean => {\n  if (el.hasAttribute('hidden')) return false;\n  if (typeof window === 'undefined') return true;\n  const style = window.getComputedStyle(el);\n  return style.display !== 'none' && style.visibility !== 'hidden';\n};\n\nconst getFocusableElements = (container: HTMLElement): HTMLElement[] =>\n  Array.from(container.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR)).filter(isElementVisible);\n\n/**\n * Returns the deepest active element across (possibly nested) shadow roots,\n * starting from the document. Plain `document.activeElement` returns the shadow\n * host when focus is inside an open shadow root, so we recurse into shadowRoot\n * to find the truly focused element.\n */\nconst getDeepActiveElement = (): HTMLElement | null => {\n  if (typeof document === 'undefined') return null;\n  let active = document.activeElement as HTMLElement | null;\n  while (active && active.shadowRoot && active.shadowRoot.activeElement) {\n    active = active.shadowRoot.activeElement as HTMLElement;\n  }\n  return active;\n};\n\n/**\n * Trap keyboard focus inside `containerRef` while `enabled` is true.\n *\n * On enable: moves focus to the first focusable element inside the container.\n * If the container is empty (e.g. lazy-loaded content), waits for DOM mutations\n * and focuses the first focusable as soon as it appears.\n *\n * While enabled: Tab and Shift+Tab wrap around so focus stays inside.\n *\n * On disable: restores focus to the previously focused element if it is still\n * present in the document.\n */\nexport const useFocusTrap = (containerRef: RefObject<HTMLElement | null>, enabled: boolean) => {\n  useEffect(() => {\n    if (!enabled || typeof document === 'undefined') return undefined;\n\n    const container = containerRef.current;\n    if (!container) return undefined;\n\n    // The container may live inside a Shadow DOM (the injection bundle hosts\n    // the chat that way). Use the container's root so containment checks and\n    // active-element lookups work both in the light DOM and inside shadow roots.\n    const root = container.getRootNode() as Document | ShadowRoot;\n    const previouslyFocused = getDeepActiveElement();\n\n    const getActiveElement = (): HTMLElement | null => root.activeElement as HTMLElement | null;\n\n    const focusFirst = (): boolean => {\n      const focusables = getFocusableElements(container);\n      const first = focusables[0];\n      if (first) {\n        first.focus();\n        return true;\n      }\n      return false;\n    };\n\n    let observer: MutationObserver | null = null;\n    if (!focusFirst()) {\n      observer = new MutationObserver(() => {\n        if (focusFirst()) {\n          observer?.disconnect();\n          observer = null;\n        }\n      });\n      observer.observe(container, { childList: true, subtree: true });\n    }\n\n    const handleKeyDown = (e: KeyboardEvent) => {\n      if (e.key !== 'Tab') return;\n\n      const focusables = getFocusableElements(container);\n      if (focusables.length === 0) {\n        e.preventDefault();\n        return;\n      }\n\n      const first = focusables[0];\n      const last = focusables[focusables.length - 1];\n      const active = getActiveElement();\n      const isInsideContainer = active ? container.contains(active) : false;\n\n      if (e.shiftKey) {\n        if (active === first || !isInsideContainer) {\n          e.preventDefault();\n          last.focus();\n        }\n      } else if (active === last || !isInsideContainer) {\n        e.preventDefault();\n        first.focus();\n      }\n    };\n\n    container.addEventListener('keydown', handleKeyDown);\n\n    return () => {\n      observer?.disconnect();\n      container.removeEventListener('keydown', handleKeyDown);\n\n      if (\n        previouslyFocused &&\n        typeof previouslyFocused.focus === 'function' &&\n        previouslyFocused.isConnected\n      ) {\n        previouslyFocused.focus();\n      }\n    };\n  }, [enabled, containerRef]);\n};\n"],"mappings":";;;;AAEA,MAAM,qBAAqB;CACzB;CACA;CACA;CACA;CACA;CACA;CACD,CAAC,KAAK,IAAI;AAEX,MAAM,oBAAoB,OAA6B;AACrD,KAAI,GAAG,aAAa,SAAS,CAAE,QAAO;AACtC,KAAI,OAAO,WAAW,YAAa,QAAO;CAC1C,MAAM,QAAQ,OAAO,iBAAiB,GAAG;AACzC,QAAO,MAAM,YAAY,UAAU,MAAM,eAAe;;AAG1D,MAAM,wBAAwB,cAC5B,MAAM,KAAK,UAAU,iBAA8B,mBAAmB,CAAC,CAAC,OAAO,iBAAiB;;;;;;;AAQlG,MAAM,6BAAiD;AACrD,KAAI,OAAO,aAAa,YAAa,QAAO;CAC5C,IAAI,SAAS,SAAS;AACtB,QAAO,UAAU,OAAO,cAAc,OAAO,WAAW,cACtD,UAAS,OAAO,WAAW;AAE7B,QAAO;;;;;;;;;;;;;;AAeT,MAAa,gBAAgB,cAA6C,YAAqB;AAC7F,4BAAgB;AACd,MAAI,CAAC,WAAW,OAAO,aAAa,YAAa,QAAO;EAExD,MAAM,YAAY,aAAa;AAC/B,MAAI,CAAC,UAAW,QAAO;EAKvB,MAAM,OAAO,UAAU,aAAa;EACpC,MAAM,oBAAoB,sBAAsB;EAEhD,MAAM,yBAA6C,KAAK;EAExD,MAAM,mBAA4B;GAEhC,MAAM,QADa,qBAAqB,UAAU,CACzB;AACzB,OAAI,OAAO;AACT,UAAM,OAAO;AACb,WAAO;;AAET,UAAO;;EAGT,IAAIA,WAAoC;AACxC,MAAI,CAAC,YAAY,EAAE;AACjB,cAAW,IAAI,uBAAuB;AACpC,QAAI,YAAY,EAAE;AAChB,eAAU,YAAY;AACtB,gBAAW;;KAEb;AACF,YAAS,QAAQ,WAAW;IAAE,WAAW;IAAM,SAAS;IAAM,CAAC;;EAGjE,MAAM,iBAAiB,MAAqB;AAC1C,OAAI,EAAE,QAAQ,MAAO;GAErB,MAAM,aAAa,qBAAqB,UAAU;AAClD,OAAI,WAAW,WAAW,GAAG;AAC3B,MAAE,gBAAgB;AAClB;;GAGF,MAAM,QAAQ,WAAW;GACzB,MAAM,OAAO,WAAW,WAAW,SAAS;GAC5C,MAAM,SAAS,kBAAkB;GACjC,MAAM,oBAAoB,SAAS,UAAU,SAAS,OAAO,GAAG;AAEhE,OAAI,EAAE,UACJ;QAAI,WAAW,SAAS,CAAC,mBAAmB;AAC1C,OAAE,gBAAgB;AAClB,UAAK,OAAO;;cAEL,WAAW,QAAQ,CAAC,mBAAmB;AAChD,MAAE,gBAAgB;AAClB,UAAM,OAAO;;;AAIjB,YAAU,iBAAiB,WAAW,cAAc;AAEpD,eAAa;AACX,aAAU,YAAY;AACtB,aAAU,oBAAoB,WAAW,cAAc;AAEvD,OACE,qBACA,OAAO,kBAAkB,UAAU,cACnC,kBAAkB,YAElB,mBAAkB,OAAO;;IAG5B,CAAC,SAAS,aAAa,CAAC"}

package/dist/hooks/FocusTrap/useFocusTrap.d.cts

@@ -0,0 +1,20 @@
+import { RefObject } from "react";
+
+//#region src/hooks/FocusTrap/useFocusTrap.d.ts
+
+/**
+ * Trap keyboard focus inside `containerRef` while `enabled` is true.
+ *
+ * On enable: moves focus to the first focusable element inside the container.
+ * If the container is empty (e.g. lazy-loaded content), waits for DOM mutations
+ * and focuses the first focusable as soon as it appears.
+ *
+ * While enabled: Tab and Shift+Tab wrap around so focus stays inside.
+ *
+ * On disable: restores focus to the previously focused element if it is still
+ * present in the document.
+ */
+declare const useFocusTrap: (containerRef: RefObject<HTMLElement | null>, enabled: boolean) => void;
+//#endregion
+export { useFocusTrap };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlRm9jdXNUcmFwLmQuY3RzIiwibmFtZXMiOltdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9ob29rcy9Gb2N1c1RyYXAvdXNlRm9jdXNUcmFwLmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmVmT2JqZWN0IH0gZnJvbSAncmVhY3QnO1xuLyoqXG4gKiBUcmFwIGtleWJvYXJkIGZvY3VzIGluc2lkZSBgY29udGFpbmVyUmVmYCB3aGlsZSBgZW5hYmxlZGAgaXMgdHJ1ZS5cbiAqXG4gKiBPbiBlbmFibGU6IG1vdmVzIGZvY3VzIHRvIHRoZSBmaXJzdCBmb2N1c2FibGUgZWxlbWVudCBpbnNpZGUgdGhlIGNvbnRhaW5lci5cbiAqIElmIHRoZSBjb250YWluZXIgaXMgZW1wdHkgKGUuZy4gbGF6eS1sb2FkZWQgY29udGVudCksIHdhaXRzIGZvciBET00gbXV0YXRpb25zXG4gKiBhbmQgZm9jdXNlcyB0aGUgZmlyc3QgZm9jdXNhYmxlIGFzIHNvb24gYXMgaXQgYXBwZWFycy5cbiAqXG4gKiBXaGlsZSBlbmFibGVkOiBUYWIgYW5kIFNoaWZ0K1RhYiB3cmFwIGFyb3VuZCBzbyBmb2N1cyBzdGF5cyBpbnNpZGUuXG4gKlxuICogT24gZGlzYWJsZTogcmVzdG9yZXMgZm9jdXMgdG8gdGhlIHByZXZpb3VzbHkgZm9jdXNlZCBlbGVtZW50IGlmIGl0IGlzIHN0aWxsXG4gKiBwcmVzZW50IGluIHRoZSBkb2N1bWVudC5cbiAqL1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgdXNlRm9jdXNUcmFwOiAoY29udGFpbmVyUmVmOiBSZWZPYmplY3Q8SFRNTEVsZW1lbnQgfCBudWxsPiwgZW5hYmxlZDogYm9vbGVhbikgPT4gdm9pZDtcbiJdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsSUFBRSxlQUFBO0NBQUE7T0FBQTtPQUFBO0NBQUEifQ==

package/dist/hooks/FocusTrap/useFocusTrap.d.ts

@@ -0,0 +1,20 @@
+import { RefObject } from "react";
+
+//#region src/hooks/FocusTrap/useFocusTrap.d.ts
+
+/**
+ * Trap keyboard focus inside `containerRef` while `enabled` is true.
+ *
+ * On enable: moves focus to the first focusable element inside the container.
+ * If the container is empty (e.g. lazy-loaded content), waits for DOM mutations
+ * and focuses the first focusable as soon as it appears.
+ *
+ * While enabled: Tab and Shift+Tab wrap around so focus stays inside.
+ *
+ * On disable: restores focus to the previously focused element if it is still
+ * present in the document.
+ */
+declare const useFocusTrap: (containerRef: RefObject<HTMLElement | null>, enabled: boolean) => void;
+//#endregion
+export { useFocusTrap };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlRm9jdXNUcmFwLmQudHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2hvb2tzL0ZvY3VzVHJhcC91c2VGb2N1c1RyYXAuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZWZPYmplY3QgfSBmcm9tICdyZWFjdCc7XG4vKipcbiAqIFRyYXAga2V5Ym9hcmQgZm9jdXMgaW5zaWRlIGBjb250YWluZXJSZWZgIHdoaWxlIGBlbmFibGVkYCBpcyB0cnVlLlxuICpcbiAqIE9uIGVuYWJsZTogbW92ZXMgZm9jdXMgdG8gdGhlIGZpcnN0IGZvY3VzYWJsZSBlbGVtZW50IGluc2lkZSB0aGUgY29udGFpbmVyLlxuICogSWYgdGhlIGNvbnRhaW5lciBpcyBlbXB0eSAoZS5nLiBsYXp5LWxvYWRlZCBjb250ZW50KSwgd2FpdHMgZm9yIERPTSBtdXRhdGlvbnNcbiAqIGFuZCBmb2N1c2VzIHRoZSBmaXJzdCBmb2N1c2FibGUgYXMgc29vbiBhcyBpdCBhcHBlYXJzLlxuICpcbiAqIFdoaWxlIGVuYWJsZWQ6IFRhYiBhbmQgU2hpZnQrVGFiIHdyYXAgYXJvdW5kIHNvIGZvY3VzIHN0YXlzIGluc2lkZS5cbiAqXG4gKiBPbiBkaXNhYmxlOiByZXN0b3JlcyBmb2N1cyB0byB0aGUgcHJldmlvdXNseSBmb2N1c2VkIGVsZW1lbnQgaWYgaXQgaXMgc3RpbGxcbiAqIHByZXNlbnQgaW4gdGhlIGRvY3VtZW50LlxuICovXG5leHBvcnQgZGVjbGFyZSBjb25zdCB1c2VGb2N1c1RyYXA6IChjb250YWluZXJSZWY6IFJlZk9iamVjdDxIVE1MRWxlbWVudCB8IG51bGw+LCBlbmFibGVkOiBib29sZWFuKSA9PiB2b2lkO1xuIl0sIm1hcHBpbmdzIjoiOzs7QUFDQSxJQUFFLGVBQUE7Q0FBQTtPQUFBO09BQUE7Q0FBQSJ9

package/dist/hooks/FocusTrap/useFocusTrap.js

@@ -0,0 +1,104 @@
+import { useEffect } from "react";
+
+//#region src/hooks/FocusTrap/useFocusTrap.ts
+const FOCUSABLE_SELECTOR = [
+	"a[href]",
+	"button:not([disabled])",
+	"input:not([disabled]):not([type=\"hidden\"])",
+	"textarea:not([disabled])",
+	"select:not([disabled])",
+	"[tabindex]:not([tabindex=\"-1\"])"
+].join(",");
+const isElementVisible = (el) => {
+	if (el.hasAttribute("hidden")) return false;
+	if (typeof window === "undefined") return true;
+	const style = window.getComputedStyle(el);
+	return style.display !== "none" && style.visibility !== "hidden";
+};
+const getFocusableElements = (container) => Array.from(container.querySelectorAll(FOCUSABLE_SELECTOR)).filter(isElementVisible);
+/**
+* Returns the deepest active element across (possibly nested) shadow roots,
+* starting from the document. Plain `document.activeElement` returns the shadow
+* host when focus is inside an open shadow root, so we recurse into shadowRoot
+* to find the truly focused element.
+*/
+const getDeepActiveElement = () => {
+	if (typeof document === "undefined") return null;
+	let active = document.activeElement;
+	while (active && active.shadowRoot && active.shadowRoot.activeElement) active = active.shadowRoot.activeElement;
+	return active;
+};
+/**
+* Trap keyboard focus inside `containerRef` while `enabled` is true.
+*
+* On enable: moves focus to the first focusable element inside the container.
+* If the container is empty (e.g. lazy-loaded content), waits for DOM mutations
+* and focuses the first focusable as soon as it appears.
+*
+* While enabled: Tab and Shift+Tab wrap around so focus stays inside.
+*
+* On disable: restores focus to the previously focused element if it is still
+* present in the document.
+*/
+const useFocusTrap = (containerRef, enabled) => {
+	useEffect(() => {
+		if (!enabled || typeof document === "undefined") return void 0;
+		const container = containerRef.current;
+		if (!container) return void 0;
+		const root = container.getRootNode();
+		const previouslyFocused = getDeepActiveElement();
+		const getActiveElement = () => root.activeElement;
+		const focusFirst = () => {
+			const first = getFocusableElements(container)[0];
+			if (first) {
+				first.focus();
+				return true;
+			}
+			return false;
+		};
+		let observer = null;
+		if (!focusFirst()) {
+			observer = new MutationObserver(() => {
+				if (focusFirst()) {
+					observer?.disconnect();
+					observer = null;
+				}
+			});
+			observer.observe(container, {
+				childList: true,
+				subtree: true
+			});
+		}
+		const handleKeyDown = (e) => {
+			if (e.key !== "Tab") return;
+			const focusables = getFocusableElements(container);
+			if (focusables.length === 0) {
+				e.preventDefault();
+				return;
+			}
+			const first = focusables[0];
+			const last = focusables[focusables.length - 1];
+			const active = getActiveElement();
+			const isInsideContainer = active ? container.contains(active) : false;
+			if (e.shiftKey) {
+				if (active === first || !isInsideContainer) {
+					e.preventDefault();
+					last.focus();
+				}
+			} else if (active === last || !isInsideContainer) {
+				e.preventDefault();
+				first.focus();
+			}
+		};
+		container.addEventListener("keydown", handleKeyDown);
+		return () => {
+			observer?.disconnect();
+			container.removeEventListener("keydown", handleKeyDown);
+			if (previouslyFocused && typeof previouslyFocused.focus === "function" && previouslyFocused.isConnected) previouslyFocused.focus();
+		};
+	}, [enabled, containerRef]);
+};
+
+//#endregion
+export { useFocusTrap };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"useFocusTrap.js","names":["observer: MutationObserver | null"],"sources":["../../../src/hooks/FocusTrap/useFocusTrap.ts"],"sourcesContent":["import { RefObject, useEffect } from 'react';\n\nconst FOCUSABLE_SELECTOR = [\n  'a[href]',\n  'button:not([disabled])',\n  'input:not([disabled]):not([type=\"hidden\"])',\n  'textarea:not([disabled])',\n  'select:not([disabled])',\n  '[tabindex]:not([tabindex=\"-1\"])',\n].join(',');\n\nconst isElementVisible = (el: HTMLElement): boolean => {\n  if (el.hasAttribute('hidden')) return false;\n  if (typeof window === 'undefined') return true;\n  const style = window.getComputedStyle(el);\n  return style.display !== 'none' && style.visibility !== 'hidden';\n};\n\nconst getFocusableElements = (container: HTMLElement): HTMLElement[] =>\n  Array.from(container.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR)).filter(isElementVisible);\n\n/**\n * Returns the deepest active element across (possibly nested) shadow roots,\n * starting from the document. Plain `document.activeElement` returns the shadow\n * host when focus is inside an open shadow root, so we recurse into shadowRoot\n * to find the truly focused element.\n */\nconst getDeepActiveElement = (): HTMLElement | null => {\n  if (typeof document === 'undefined') return null;\n  let active = document.activeElement as HTMLElement | null;\n  while (active && active.shadowRoot && active.shadowRoot.activeElement) {\n    active = active.shadowRoot.activeElement as HTMLElement;\n  }\n  return active;\n};\n\n/**\n * Trap keyboard focus inside `containerRef` while `enabled` is true.\n *\n * On enable: moves focus to the first focusable element inside the container.\n * If the container is empty (e.g. lazy-loaded content), waits for DOM mutations\n * and focuses the first focusable as soon as it appears.\n *\n * While enabled: Tab and Shift+Tab wrap around so focus stays inside.\n *\n * On disable: restores focus to the previously focused element if it is still\n * present in the document.\n */\nexport const useFocusTrap = (containerRef: RefObject<HTMLElement | null>, enabled: boolean) => {\n  useEffect(() => {\n    if (!enabled || typeof document === 'undefined') return undefined;\n\n    const container = containerRef.current;\n    if (!container) return undefined;\n\n    // The container may live inside a Shadow DOM (the injection bundle hosts\n    // the chat that way). Use the container's root so containment checks and\n    // active-element lookups work both in the light DOM and inside shadow roots.\n    const root = container.getRootNode() as Document | ShadowRoot;\n    const previouslyFocused = getDeepActiveElement();\n\n    const getActiveElement = (): HTMLElement | null => root.activeElement as HTMLElement | null;\n\n    const focusFirst = (): boolean => {\n      const focusables = getFocusableElements(container);\n      const first = focusables[0];\n      if (first) {\n        first.focus();\n        return true;\n      }\n      return false;\n    };\n\n    let observer: MutationObserver | null = null;\n    if (!focusFirst()) {\n      observer = new MutationObserver(() => {\n        if (focusFirst()) {\n          observer?.disconnect();\n          observer = null;\n        }\n      });\n      observer.observe(container, { childList: true, subtree: true });\n    }\n\n    const handleKeyDown = (e: KeyboardEvent) => {\n      if (e.key !== 'Tab') return;\n\n      const focusables = getFocusableElements(container);\n      if (focusables.length === 0) {\n        e.preventDefault();\n        return;\n      }\n\n      const first = focusables[0];\n      const last = focusables[focusables.length - 1];\n      const active = getActiveElement();\n      const isInsideContainer = active ? container.contains(active) : false;\n\n      if (e.shiftKey) {\n        if (active === first || !isInsideContainer) {\n          e.preventDefault();\n          last.focus();\n        }\n      } else if (active === last || !isInsideContainer) {\n        e.preventDefault();\n        first.focus();\n      }\n    };\n\n    container.addEventListener('keydown', handleKeyDown);\n\n    return () => {\n      observer?.disconnect();\n      container.removeEventListener('keydown', handleKeyDown);\n\n      if (\n        previouslyFocused &&\n        typeof previouslyFocused.focus === 'function' &&\n        previouslyFocused.isConnected\n      ) {\n        previouslyFocused.focus();\n      }\n    };\n  }, [enabled, containerRef]);\n};\n"],"mappings":";;;AAEA,MAAM,qBAAqB;CACzB;CACA;CACA;CACA;CACA;CACA;CACD,CAAC,KAAK,IAAI;AAEX,MAAM,oBAAoB,OAA6B;AACrD,KAAI,GAAG,aAAa,SAAS,CAAE,QAAO;AACtC,KAAI,OAAO,WAAW,YAAa,QAAO;CAC1C,MAAM,QAAQ,OAAO,iBAAiB,GAAG;AACzC,QAAO,MAAM,YAAY,UAAU,MAAM,eAAe;;AAG1D,MAAM,wBAAwB,cAC5B,MAAM,KAAK,UAAU,iBAA8B,mBAAmB,CAAC,CAAC,OAAO,iBAAiB;;;;;;;AAQlG,MAAM,6BAAiD;AACrD,KAAI,OAAO,aAAa,YAAa,QAAO;CAC5C,IAAI,SAAS,SAAS;AACtB,QAAO,UAAU,OAAO,cAAc,OAAO,WAAW,cACtD,UAAS,OAAO,WAAW;AAE7B,QAAO;;;;;;;;;;;;;;AAeT,MAAa,gBAAgB,cAA6C,YAAqB;AAC7F,iBAAgB;AACd,MAAI,CAAC,WAAW,OAAO,aAAa,YAAa,QAAO;EAExD,MAAM,YAAY,aAAa;AAC/B,MAAI,CAAC,UAAW,QAAO;EAKvB,MAAM,OAAO,UAAU,aAAa;EACpC,MAAM,oBAAoB,sBAAsB;EAEhD,MAAM,yBAA6C,KAAK;EAExD,MAAM,mBAA4B;GAEhC,MAAM,QADa,qBAAqB,UAAU,CACzB;AACzB,OAAI,OAAO;AACT,UAAM,OAAO;AACb,WAAO;;AAET,UAAO;;EAGT,IAAIA,WAAoC;AACxC,MAAI,CAAC,YAAY,EAAE;AACjB,cAAW,IAAI,uBAAuB;AACpC,QAAI,YAAY,EAAE;AAChB,eAAU,YAAY;AACtB,gBAAW;;KAEb;AACF,YAAS,QAAQ,WAAW;IAAE,WAAW;IAAM,SAAS;IAAM,CAAC;;EAGjE,MAAM,iBAAiB,MAAqB;AAC1C,OAAI,EAAE,QAAQ,MAAO;GAErB,MAAM,aAAa,qBAAqB,UAAU;AAClD,OAAI,WAAW,WAAW,GAAG;AAC3B,MAAE,gBAAgB;AAClB;;GAGF,MAAM,QAAQ,WAAW;GACzB,MAAM,OAAO,WAAW,WAAW,SAAS;GAC5C,MAAM,SAAS,kBAAkB;GACjC,MAAM,oBAAoB,SAAS,UAAU,SAAS,OAAO,GAAG;AAEhE,OAAI,EAAE,UACJ;QAAI,WAAW,SAAS,CAAC,mBAAmB;AAC1C,OAAE,gBAAgB;AAClB,UAAK,OAAO;;cAEL,WAAW,QAAQ,CAAC,mBAAmB;AAChD,MAAE,gBAAgB;AAClB,UAAM,OAAO;;;AAIjB,YAAU,iBAAiB,WAAW,cAAc;AAEpD,eAAa;AACX,aAAU,YAAY;AACtB,aAAU,oBAAoB,WAAW,cAAc;AAEvD,OACE,qBACA,OAAO,kBAAkB,UAAU,cACnC,kBAAkB,YAElB,mBAAkB,OAAO;;IAG5B,CAAC,SAAS,aAAa,CAAC"}

package/dist/hooks/GrabAndScroll/useGrabAndScroll.d.cts

@@ -1,8 +1,8 @@
-import * as react0 from "react";
+import * as react1 from "react";
 
 //#region src/hooks/GrabAndScroll/useGrabAndScroll.d.ts
 declare const useGrabAndScroll: (enabled: boolean, chunkWidth: number, speed?: number, offset?: number) => {
-  containerRef: react0.RefObject<HTMLDivElement | null>;
+  containerRef: react1.RefObject<HTMLDivElement | null>;
   leftArrow: boolean;
   rightArrow: boolean;
   animationTrigger: () => void;

package/dist/hooks/SystemSettingsContext/useSystemSettingsContext.d.cts

@@ -1,12 +1,12 @@
 import { GenerationParams } from "../../application/models/api/generationParams.cjs";
-import * as react1 from "react";
+import * as react0 from "react";
 
 //#region src/hooks/SystemSettingsContext/useSystemSettingsContext.d.ts
 declare const useSystemSettingsContext: () => {
   generationParams?: GenerationParams;
   showDebugBar?: boolean;
   endpointURL?: string;
-  setGenerationParams: react1.Dispatch<react1.SetStateAction<GenerationParams | undefined>>;
+  setGenerationParams: react0.Dispatch<react0.SetStateAction<GenerationParams | undefined>>;
 };
 //#endregion
 export { useSystemSettingsContext };

package/dist/hooks/utils.d.cts

@@ -19,4 +19,4 @@ declare enum SearchResultsState {
 declare const getSearchResultsState: (isLoadingSearch: boolean, searchData: SearchResult | null) => SearchResultsState;
 //#endregion
 export { SearchResultsState, createAppLoadedEvent, createVisitUserEvent, getSearchResultsState, isElementPartiallyVisible, isWithinBusinessHours };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL2hvb2tzL3V0aWxzLmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2VhcmNoUmVzdWx0IH0gZnJvbSAnc3JjL2FwcGxpY2F0aW9uL21vZGVscy9hcGkvc2VhcmNoJztcbmltcG9ydCB7IFVzZXJFdmVudCwgVmFyaWFudEluZm8gfSBmcm9tICdzcmMvYXBwbGljYXRpb24vbW9kZWxzJztcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGlzRWxlbWVudFBhcnRpYWxseVZpc2libGU6IChlbD86IEhUTUxEaXZFbGVtZW50IHwgbnVsbCkgPT4gYm9vbGVhbjtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGNyZWF0ZUFwcExvYWRlZEV2ZW50OiAoKSA9PiBVc2VyRXZlbnQ7XG5leHBvcnQgZGVjbGFyZSBjb25zdCBjcmVhdGVWaXNpdFVzZXJFdmVudDogKHsgdmFyaWFudEluZm8sIH06IHtcbiAgICB2YXJpYW50SW5mbzogVmFyaWFudEluZm87XG59KSA9PiBVc2VyRXZlbnQgfCB1bmRlZmluZWQ7XG5leHBvcnQgZGVjbGFyZSBjb25zdCBpc1dpdGhpbkJ1c2luZXNzSG91cnM6IChzdGFydFRpbWU6IHN0cmluZywgZW5kVGltZTogc3RyaW5nLCB0aW1lWm9uZTogc3RyaW5nKSA9PiBib29sZWFuO1xuZXhwb3J0IGRlY2xhcmUgZW51bSBTZWFyY2hSZXN1bHRzU3RhdGUge1xuICAgIExvYWRpbmcgPSAwLFxuICAgIFJlc3VsdHMgPSAxLFxuICAgIE5vUmVzdWx0cyA9IDJcbn1cbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGdldFNlYXJjaFJlc3VsdHNTdGF0ZTogKGlzTG9hZGluZ1NlYXJjaDogYm9vbGVhbiwgc2VhcmNoRGF0YTogU2VhcmNoUmVzdWx0IHwgbnVsbCkgPT4gU2VhcmNoUmVzdWx0c1N0YXRlO1xuIl0sIm1hcHBpbmdzIjoiOzs7OztBQUVBLElBQVcsNEJBQTRCLENBQUMsU0FBUyxlQUFlO0FBQ2hFLElBQVcsdUJBQXVCLENBQUMsU0FBUyxVQUFVO0FBQ3RELElBQVcsdUJBQXVCO0NBQUM7T0FBUztPQUFrQjtPQUFBO0NBQUE7QUFDOUQsSUFBVyx3QkFBaUIsQ0FBQSxFQUFBO0FBQzVCLElBQVcscUJBQWdCLENBQUEsRUFBQTtBQUMzQixJQUFXLHdCQUF3QjtDQUFDO09BQVM7T0FBb0I7Q0FBbUIifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL2hvb2tzL3V0aWxzLmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2VhcmNoUmVzdWx0IH0gZnJvbSAnc3JjL2FwcGxpY2F0aW9uL21vZGVscy9hcGkvc2VhcmNoJztcbmltcG9ydCB7IFVzZXJFdmVudCwgVmFyaWFudEluZm8gfSBmcm9tICdzcmMvYXBwbGljYXRpb24vbW9kZWxzJztcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGlzRWxlbWVudFBhcnRpYWxseVZpc2libGU6IChlbD86IEhUTUxEaXZFbGVtZW50IHwgbnVsbCkgPT4gYm9vbGVhbjtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGNyZWF0ZUFwcExvYWRlZEV2ZW50OiAoKSA9PiBVc2VyRXZlbnQ7XG5leHBvcnQgZGVjbGFyZSBjb25zdCBjcmVhdGVWaXNpdFVzZXJFdmVudDogKHsgdmFyaWFudEluZm8sIH06IHtcbiAgICB2YXJpYW50SW5mbzogVmFyaWFudEluZm87XG59KSA9PiBVc2VyRXZlbnQgfCB1bmRlZmluZWQ7XG5leHBvcnQgZGVjbGFyZSBjb25zdCBpc1dpdGhpbkJ1c2luZXNzSG91cnM6IChzdGFydFRpbWU6IHN0cmluZywgZW5kVGltZTogc3RyaW5nLCB0aW1lWm9uZTogc3RyaW5nKSA9PiBib29sZWFuO1xuZXhwb3J0IGRlY2xhcmUgZW51bSBTZWFyY2hSZXN1bHRzU3RhdGUge1xuICAgIExvYWRpbmcgPSAwLFxuICAgIFJlc3VsdHMgPSAxLFxuICAgIE5vUmVzdWx0cyA9IDJcbn1cbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGdldFNlYXJjaFJlc3VsdHNTdGF0ZTogKGlzTG9hZGluZ1NlYXJjaDogYm9vbGVhbiwgc2VhcmNoRGF0YTogU2VhcmNoUmVzdWx0IHwgbnVsbCkgPT4gU2VhcmNoUmVzdWx0c1N0YXRlO1xuIl0sIm1hcHBpbmdzIjoiOzs7OztBQUVBLElBQVcsNEJBQTRCLENBQUMsVUFBVSxlQUFlO0FBQ2pFLElBQVcsdUJBQXVCLENBQUMsVUFBVSxVQUFVO0FBQ3ZELElBQVcsdUJBQXVCO0NBQUM7T0FBVTtPQUFpQjtPQUFBO0NBQUE7QUFDOUQsSUFBVyx3QkFBaUIsQ0FBQSxHQUFBO0FBQzVCLElBQVcscUJBQWdCLENBQUEsR0FBQTtBQUMzQixJQUFXLHdCQUF3QjtDQUFDO09BQVU7T0FBb0I7Q0FBbUIifQ==

package/dist/hooks/utils.d.ts

@@ -19,4 +19,4 @@ declare enum SearchResultsState {
 declare const getSearchResultsState: (isLoadingSearch: boolean, searchData: SearchResult | null) => SearchResultsState;
 //#endregion
 export { SearchResultsState, createAppLoadedEvent, createVisitUserEvent, getSearchResultsState, isElementPartiallyVisible, isWithinBusinessHours };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi9zcmMvaG9va3MvdXRpbHMuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTZWFyY2hSZXN1bHQgfSBmcm9tICdzcmMvYXBwbGljYXRpb24vbW9kZWxzL2FwaS9zZWFyY2gnO1xuaW1wb3J0IHsgVXNlckV2ZW50LCBWYXJpYW50SW5mbyB9IGZyb20gJ3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMnO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgaXNFbGVtZW50UGFydGlhbGx5VmlzaWJsZTogKGVsPzogSFRNTERpdkVsZW1lbnQgfCBudWxsKSA9PiBib29sZWFuO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgY3JlYXRlQXBwTG9hZGVkRXZlbnQ6ICgpID0+IFVzZXJFdmVudDtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGNyZWF0ZVZpc2l0VXNlckV2ZW50OiAoeyB2YXJpYW50SW5mbywgfToge1xuICAgIHZhcmlhbnRJbmZvOiBWYXJpYW50SW5mbztcbn0pID0+IFVzZXJFdmVudCB8IHVuZGVmaW5lZDtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGlzV2l0aGluQnVzaW5lc3NIb3VyczogKHN0YXJ0VGltZTogc3RyaW5nLCBlbmRUaW1lOiBzdHJpbmcsIHRpbWVab25lOiBzdHJpbmcpID0+IGJvb2xlYW47XG5leHBvcnQgZGVjbGFyZSBlbnVtIFNlYXJjaFJlc3VsdHNTdGF0ZSB7XG4gICAgTG9hZGluZyA9IDAsXG4gICAgUmVzdWx0cyA9IDEsXG4gICAgTm9SZXN1bHRzID0gMlxufVxuZXhwb3J0IGRlY2xhcmUgY29uc3QgZ2V0U2VhcmNoUmVzdWx0c1N0YXRlOiAoaXNMb2FkaW5nU2VhcmNoOiBib29sZWFuLCBzZWFyY2hEYXRhOiBTZWFyY2hSZXN1bHQgfCBudWxsKSA9PiBTZWFyY2hSZXN1bHRzU3RhdGU7XG4iXSwibWFwcGluZ3MiOiI7Ozs7O0FBRUEsSUFBVyw0QkFBNEIsQ0FBQyxTQUFTLGVBQWU7QUFDaEUsSUFBVyx1QkFBdUIsQ0FBQyxTQUFTLFVBQVU7QUFDdEQsSUFBVyx1QkFBdUI7Q0FBQztPQUFTO09BQWtCO09BQUE7Q0FBQTtBQUM5RCxJQUFXLHdCQUFpQixDQUFBLEVBQUE7QUFDNUIsSUFBVyxxQkFBZ0IsQ0FBQSxFQUFBO0FBQzNCLElBQVcsd0JBQXdCO0NBQUM7T0FBUztPQUFvQjtDQUFtQiJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi9zcmMvaG9va3MvdXRpbHMuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTZWFyY2hSZXN1bHQgfSBmcm9tICdzcmMvYXBwbGljYXRpb24vbW9kZWxzL2FwaS9zZWFyY2gnO1xuaW1wb3J0IHsgVXNlckV2ZW50LCBWYXJpYW50SW5mbyB9IGZyb20gJ3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMnO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgaXNFbGVtZW50UGFydGlhbGx5VmlzaWJsZTogKGVsPzogSFRNTERpdkVsZW1lbnQgfCBudWxsKSA9PiBib29sZWFuO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgY3JlYXRlQXBwTG9hZGVkRXZlbnQ6ICgpID0+IFVzZXJFdmVudDtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGNyZWF0ZVZpc2l0VXNlckV2ZW50OiAoeyB2YXJpYW50SW5mbywgfToge1xuICAgIHZhcmlhbnRJbmZvOiBWYXJpYW50SW5mbztcbn0pID0+IFVzZXJFdmVudCB8IHVuZGVmaW5lZDtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGlzV2l0aGluQnVzaW5lc3NIb3VyczogKHN0YXJ0VGltZTogc3RyaW5nLCBlbmRUaW1lOiBzdHJpbmcsIHRpbWVab25lOiBzdHJpbmcpID0+IGJvb2xlYW47XG5leHBvcnQgZGVjbGFyZSBlbnVtIFNlYXJjaFJlc3VsdHNTdGF0ZSB7XG4gICAgTG9hZGluZyA9IDAsXG4gICAgUmVzdWx0cyA9IDEsXG4gICAgTm9SZXN1bHRzID0gMlxufVxuZXhwb3J0IGRlY2xhcmUgY29uc3QgZ2V0U2VhcmNoUmVzdWx0c1N0YXRlOiAoaXNMb2FkaW5nU2VhcmNoOiBib29sZWFuLCBzZWFyY2hEYXRhOiBTZWFyY2hSZXN1bHQgfCBudWxsKSA9PiBTZWFyY2hSZXN1bHRzU3RhdGU7XG4iXSwibWFwcGluZ3MiOiI7Ozs7O0FBRUEsSUFBVyw0QkFBNEIsQ0FBQyxXQUFXLGVBQWU7QUFDbEUsSUFBVyx1QkFBdUIsQ0FBQyxXQUFXLFVBQVU7QUFDeEQsSUFBVyx1QkFBdUI7Q0FBQztPQUFXO09BQWdCO09BQUE7Q0FBQTtBQUM5RCxJQUFXLHdCQUFpQixDQUFBLElBQUE7QUFDNUIsSUFBVyxxQkFBZ0IsQ0FBQSxJQUFBO0FBQzNCLElBQVcsd0JBQXdCO0NBQUM7T0FBVztPQUFvQjtDQUFtQiJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@envive-ai/react-hooks",
-  "version": "0.3.40",
+  "version": "0.3.42",
   "description": "React hooks for connecting to Envive AI services.",
   "keywords": [
     "react",
@@ -306,6 +306,10 @@
       "import": "./dist/hooks/ElementObserver/index.js",
       "require": "./dist/hooks/ElementObserver/index.cjs"
     },
+    "./hooks/FocusTrap": {
+      "import": "./dist/hooks/FocusTrap/index.js",
+      "require": "./dist/hooks/FocusTrap/index.cjs"
+    },
     "./hooks/GrabAndScroll": {
       "import": "./dist/hooks/GrabAndScroll/index.js",
       "require": "./dist/hooks/GrabAndScroll/index.cjs"

package/src/contexts/enviveCssContext/enviveCssContext.tsx

@@ -71,6 +71,7 @@ export const EnviveCssProvider: React.FC<EnviveCssProviderProps> = ({ children }
   --${ColorsNamesVars.AccentSecondary}: ${colorsConfig.accentSecondary};
 
   --${ButtonColorsVars.LightButtonBackgroundColor}: ${configV3.uiConfigs?.lookAndFeel?.buttonColors?.lightButtonBackgroundColor};
+  ${configV3.uiConfigs?.lookAndFeel?.buttonColors?.lightButtonBorderColor ? `--${ButtonColorsVars.LightButtonBorderColor}: ${configV3.uiConfigs.lookAndFeel.buttonColors.lightButtonBorderColor};` : ''}
   --${ButtonColorsVars.LightButtonIconColor}: ${configV3.uiConfigs?.lookAndFeel?.buttonColors?.lightButtonIconColor};
   --${ButtonColorsVars.DarkButtonBackgroundColor}: ${configV3.uiConfigs?.lookAndFeel?.buttonColors?.darkButtonBackgroundColor};
   --${ButtonColorsVars.DarkButtonIconColor}: ${configV3.uiConfigs?.lookAndFeel?.buttonColors?.darkButtonIconColor};

package/src/contexts/typesV3.ts

@@ -103,6 +103,7 @@ export const enum ColorsNamesVars {
 
 export const enum ButtonColorsVars {
   LightButtonBackgroundColor = 'envive-colors-button-light-background-color',
+  LightButtonBorderColor = 'envive-colors-button-light-border-color',
   LightButtonIconColor = 'envive-colors-button-light-icon-color',
   DarkButtonBackgroundColor = 'envive-colors-button-dark-background-color',
   DarkButtonIconColor = 'envive-colors-button-dark-icon-color',
@@ -112,6 +113,7 @@ type ImageAspectRatio = '1/1' | '3/4';
 
 type ButtonColors = {
   lightButtonBackgroundColor: string;
+  lightButtonBorderColor?: string;
   lightButtonIconColor: string;
   darkButtonBackgroundColor: string;
   darkButtonIconColor: string;