playbook_ui 13.24.0 → 13.25.0.pre.alpha.PBNTR291Dropdownrailsv22812

data/app/pb_kits/playbook/pb_dialog/dialog_footer.html.erb

@@ -1,8 +1,4 @@
-<%= content_tag(:div,
-    id: object.id,
-    data: object.data,
-    aria: object.aria,
-    **combined_html_options) do %>
+<%= pb_content_tag do %>
     <% if object.confirm_button && object.cancel_button %>
         <div class="dialog-pseudo-footer"></div>
         <%= pb_rails("flex", props: { classname:object.classname, spacing:"between", padding_x:"sm", padding:"sm", padding_bottom:"sm" }) do %>

data/app/pb_kits/playbook/pb_dialog/dialog_header.html.erb

@@ -1,9 +1,5 @@
-<%= content_tag(:div,
-    id: object.id,
-    data: object.data,
-    class: object.sticky_header,
-    aria: object.aria,
-    **combined_html_options) do %>
+<%= pb_content_tag(:div,
+    class: object.sticky_header) do %>
         <%= pb_rails("flex", props: {classname:object.classname, spacing:"between", padding:"sm", align:"center"}) do %>
             <%= content.presence || object.title %>
 

data/app/pb_kits/playbook/pb_dialog/docs/example.yml

@@ -27,5 +27,5 @@ examples:
   - dialog_default_swift: Simple
   - dialog_sizes_swift: Sizes
   - dialog_status_swift: Status
-  - dialog_props_table: ""
+  - dialog_props_swift: ""
   

data/app/pb_kits/playbook/pb_dropdown/_dropdown.scss

@@ -0,0 +1,164 @@
+@import "../tokens/colors";
+@import "../tokens/spacing";
+@import "../tokens/typography";
+@import "../tokens/border_radius";
+@import "../tokens/shadows";
+@import "../tokens/positioning";
+@import "../pb_body/body_mixins";
+@import "../pb_textarea/textarea_mixin";
+
+@import "./scss_partials/dropdown_animation";
+
+.pb_dropdown {
+  .dropdown_wrapper {
+    [class*="dropdown_trigger_wrapper"] {
+      @include pb_body;
+      border: 1px solid $border_light;
+      background-color: $white;
+      height: 45px;
+      @media (hover: hover) {
+        &:hover,
+        &:active,
+        &:focus {
+          background-color: $focus_input_light;
+          input {
+            background-color: $focus_input_light;
+          }
+        }
+      }
+
+      .dropdown_input {
+        @include pb_body;
+        border: unset;
+        padding: 0;
+        background-color: $white;
+        &:focus-visible {
+          outline: none;
+        }
+      }
+      &:focus {
+        box-shadow: 0px 0px 0 1px $primary !important;
+        outline: unset;
+        transition: box-shadow 0.15s ease-in-out;
+      }
+
+      &[class*="_select_only"] {
+        box-shadow: inset 0 -11px 20px rgba($primary, 0.05);
+      }
+
+      &[class*="_focus"] {
+        box-shadow: 0px 0px 0 1px $primary !important;
+        transition: box-shadow 0.1s ease-in-out;
+      }
+    }
+
+    .pb_dropdown_container {
+      background-color: $white;
+      overflow: hidden;
+      box-shadow: $shadow_deep;
+      border-radius: $border_rad_heavier;
+      border: 1px solid $border_light;
+      margin-top: $space_xs;
+      z-index: $z_1;
+      width: 100%;
+
+      [class*="pb_dropdown_option"] {
+        cursor: pointer;
+        &:hover {
+          background-color: $border_light;
+        }
+
+        &[class*="_focused"] {
+          background-color: $border_light;
+        }
+
+        &[class*="_list"] {
+          border-bottom: 1px solid $border_light;
+        }
+        &[class*="selected"] {
+          background-color: $primary;
+          [class^="pb_body"],
+          [class^="pb_title_kit"] {
+            color: $white !important;
+          }
+          &:hover {
+            background-color: $primary !important;
+          }
+        }
+      }
+
+      .dropdown_option_wrapper {
+        width: 100%;
+      }
+    }
+    .close {
+      display: none;
+      animation-name: fadeOut;
+      animation-duration: 150ms;
+      animation-timing-function: linear;
+      animation-fill-mode: forwards;
+    }
+
+    .open {
+      display: block;
+      animation-name: fadeIn;
+      animation-duration: 150ms;
+      animation-timing-function: linear;
+      animation-fill-mode: forwards;
+    }
+  }
+
+  &.dark {
+    .dropdown_wrapper {
+      [class*="dropdown_trigger_wrapper"] {
+        @include pb_body_light_dark;
+        background-color: rgba($white, 0.1) !important;
+        background: none;
+        border-color: rgba($white, 0.15);
+        @media (hover: hover) {
+          &:hover,
+          &:active,
+          &:focus {
+            background-color: rgba($white, 0.05) !important;
+          }
+        }
+        [class^="pb_body"] {
+          color: $white;
+        }
+        &[class*="_select_only"] {
+          box-shadow: inset 0 -11px 20px rgba($white, 0.05);
+        }
+        .dropdown_input {
+          background-color: unset;
+          color: $white;
+        }
+      }
+    }
+    .pb_dropdown_container {
+      background-color: $bg_dark !important;
+      border-color: rgba($white, 0.15);
+      color: $white;
+      [class^="pb_body"],
+      [class^="pb_title_kit"] {
+        color: $white !important;
+      }
+
+      [class*="pb_dropdown_option"] {
+        &:hover {
+          background-color: $hover_dark;
+        }
+
+        &[class*="_focused"] {
+          background-color: $hover_dark;
+        }
+
+        &[class*="_list"] {
+          border-color: rgba($white, 0.15);
+        }
+        &[class*="selected"] {
+          background-color: $primary;
+        }
+      }
+    }
+  }
+}

data/app/pb_kits/playbook/pb_dropdown/_dropdown.tsx

@@ -0,0 +1,253 @@
+import React, { useState, useRef, useEffect } from "react";
+import classnames from "classnames";
+import { buildAriaProps, buildCss, buildDataProps, buildHtmlProps } from "../utilities/props";
+import { globalProps } from "../utilities/globalProps";
+import { GenericObject } from "../types";
+
+import Body from "../pb_body/_body";
+import Caption from "../pb_caption/_caption";
+
+import DropdownContainer from "./subcomponents/DropdownContainer";
+import DropdownContext from "./context";
+import DropdownOption from "./subcomponents/DropdownOption";
+import DropdownTrigger from "./subcomponents/DropdownTrigger";
+import useDropdown from "./hooks/useDropdown";
+
+import {
+  separateChildComponents,
+  prepareSubcomponents,
+  handleClickOutside,
+} from "./utilities";
+
+type DropdownProps = {
+  aria?: { [key: string]: string };
+  autocomplete?: boolean;
+  children?: React.ReactChild[] | React.ReactChild | React.ReactElement[];
+  className?: string;
+  dark?: boolean;
+  data?: { [key: string]: string };
+  htmlOptions?: {[key: string]: string | number | boolean | (() => void)},
+  id?: string;
+  isClosed?: boolean;
+  label?: string;
+  onSelect?: (arg: GenericObject) => null;
+  options: GenericObject;
+  triggerRef?: any;
+};
+
+const Dropdown = (props: DropdownProps) => {
+  const {
+    aria = {},
+    autocomplete = false,
+    children,
+    className,
+    dark = false,
+    data = {},
+    htmlOptions = {},
+    id,
+    isClosed = true,
+    label,
+    onSelect,
+    options,
+    triggerRef
+  } = props;
+
+  const ariaProps = buildAriaProps(aria);
+  const dataProps = buildDataProps(data);
+  const htmlProps = buildHtmlProps(htmlOptions);
+  const classes = classnames(
+    buildCss("pb_dropdown"),
+    globalProps(props),
+    className
+  );
+
+  const [isDropDownClosed, setIsDropDownClosed, toggleDropdown] = useDropdown(isClosed);
+
+  const [filterItem, setFilterItem] = useState("");
+  const [selected, setSelected] = useState<GenericObject>({});
+  const [isInputFocused, setIsInputFocused] = useState(false);
+  const [hasTriggerSubcomponent, setHasTriggerSubcomponent] = useState(true);
+  const [hasContainerSubcomponent, setHasContainerSubcomponent] =
+    useState(true);
+  //state for keyboard events
+  const [focusedOptionIndex, setFocusedOptionIndex] = useState(-1);
+
+  const dropdownRef = useRef(null);
+  const inputRef = useRef(null);
+  const inputWrapperRef = useRef(null);
+  const dropdownContainerRef = useRef(null);
+
+  const { trigger, container, otherChildren } =
+    separateChildComponents(children);
+
+  useEffect(() => {
+    // Set the parent element of the trigger to relative to allow for absolute positioning of the dropdown
+    //Only needed for when useDropdown hook used with external trigger
+    if (triggerRef?.current) {
+      const parentElement = triggerRef.current.parentNode;
+      if (parentElement) {
+          parentElement.style.position = 'relative';
+      }
+  }
+  // Handle clicks outside the dropdown
+  const handleClick = handleClickOutside({
+    inputWrapperRef,
+    dropdownContainerRef,
+    setIsDropDownClosed,
+    setFocusedOptionIndex,
+    setIsInputFocused,
+  });
+  
+    window.addEventListener("click", handleClick);
+    return () => {
+      window.removeEventListener("click", handleClick);
+    };
+  }, []);
+
+  useEffect(() => {
+    setHasTriggerSubcomponent(!!trigger);
+    setHasContainerSubcomponent(!!container);
+  }, []);
+
+// dropdown to toggle with external control
+  useEffect(()=> {
+    setIsDropDownClosed(isClosed)
+   },[isClosed])
+
+  const filteredOptions = options?.filter((option: GenericObject) =>
+    option.label.toLowerCase().includes(filterItem.toLowerCase())
+  );
+
+// For keyboard accessibility: Set focus within dropdown to selected item if it exists
+  useEffect(() => {
+    if (!isDropDownClosed) { 
+        let newIndex = 0; 
+        if (selected && selected?.label) {
+            const selectedIndex = filteredOptions.findIndex((option: GenericObject) => option.label === selected.label);
+            if (selectedIndex >= 0) {
+                newIndex = selectedIndex;
+            }
+        }
+        setFocusedOptionIndex(newIndex);
+    }
+}, [isDropDownClosed]);
+
+
+  const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    setFilterItem(e.target.value);
+    setIsDropDownClosed(false);
+  };
+
+  const handleOptionClick = (selectedItem: GenericObject) => {
+    setSelected(selectedItem);
+    setFilterItem("");
+    setIsDropDownClosed(true);
+    onSelect && onSelect(selectedItem);
+  };
+
+  const handleWrapperClick = () => {
+    autocomplete && inputRef.current.focus();
+    toggleDropdown();
+  };
+
+  const handleBackspace = () => {
+    setSelected({});
+    onSelect && onSelect(null);
+    setFocusedOptionIndex(-1);
+  };
+
+  const componentsToRender = prepareSubcomponents({
+    children,
+    hasTriggerSubcomponent,
+    hasContainerSubcomponent,
+    trigger,
+    container,
+    otherChildren,
+    dark
+  });
+
+
+  return (
+    <div {...ariaProps} 
+        {...dataProps} 
+        {...htmlProps}
+        className={classes} 
+        id={id}
+        style={triggerRef ? { position: "absolute"} : { position: "relative"}}
+    >
+      <DropdownContext.Provider
+          value={{
+              autocomplete,
+              dropdownContainerRef,
+              filteredOptions,
+              filterItem,
+              focusedOptionIndex,
+              handleBackspace,
+              handleChange,
+              handleOptionClick,
+              handleWrapperClick,
+              inputRef,
+              inputWrapperRef,
+              isDropDownClosed,
+              isInputFocused,
+              options,
+              selected,
+              setFocusedOptionIndex,
+              setIsDropDownClosed,
+              setIsInputFocused,
+              setSelected,
+              toggleDropdown,
+              triggerRef
+          }}
+      >
+        {label &&
+        <Caption
+            dark={dark}
+            marginBottom="xs"
+            text={label}
+        />
+        }
+        <div className="dropdown_wrapper" 
+            onBlur={() => {
+                // Debounce to delay the execution to prevent jumpiness in Focus state
+                setTimeout(() => {
+                    if (!dropdownRef.current.contains(document.activeElement)) {
+                        setIsInputFocused(false);
+                    }
+                }, 0);
+            }}
+            onFocus={() => setIsInputFocused(true)}
+            ref={dropdownRef}
+        >
+          {children ? (
+            <>
+              {componentsToRender.map((component, index) => (
+                <React.Fragment key={index}>{component}</React.Fragment>
+              ))}
+            </>
+          ) : (
+            <>
+              <DropdownTrigger />
+              <DropdownContainer>
+                {options &&
+                  options?.map((option: GenericObject) => (
+                    <Dropdown.Option key={option.id} 
+                        option={option}
+                    >
+                      <Body text={option.label} />
+                    </Dropdown.Option>
+                  ))}
+              </DropdownContainer>
+            </>
+          )}
+        </div>
+      </DropdownContext.Provider>
+    </div>
+  )
+};
+
+Dropdown.Option = DropdownOption;
+Dropdown.Trigger = DropdownTrigger;
+Dropdown.Container = DropdownContainer;
+
+export default Dropdown;

data/app/pb_kits/playbook/pb_dropdown/context/index.tsx

@@ -0,0 +1,5 @@
+import { createContext } from "react";
+
+const DropdownContext = createContext<any>({});
+
+export default DropdownContext;

data/app/pb_kits/playbook/pb_dropdown/docs/_dropdown_default.html.erb

@@ -0,0 +1,10 @@
+<% 
+  options = [
+    { label: 'United States', value: 'United States', id: 'us' },
+    { label: 'Canada', value: 'Canada', id: 'ca' },
+    { label: 'Pakistan', value: 'Pakistan', id: 'pk' },
+  ]
+
+%>
+
+<%= pb_rails("dropdown", props: {options: options}) %>

data/app/pb_kits/playbook/pb_dropdown/docs/_dropdown_default.jsx

@@ -0,0 +1,32 @@
+import React from 'react'
+import { Dropdown } from '../../'
+
+const DropdownDefault = (props) => {
+
+  const options = [
+    {
+      label: "United States",
+      value: "United States",
+    },
+    {
+      label: "Canada",
+      value: "Canada",
+    },
+    {
+      label: "Pakistan",
+      value: "Pakistan",
+    }
+  ];  
+
+
+  return (
+  <div>
+    <Dropdown
+        options={options}
+        {...props}
+    />
+  </div>
+  )
+}
+
+export default DropdownDefault

data/app/pb_kits/playbook/pb_dropdown/docs/_dropdown_default.md

@@ -0,0 +1 @@
+The Dropdown kit accepts an `options` array and renders each object from that array as a selectable option within a dropdown container. `options` is a required prop and must be an array of objects. Each object can contain as many key/value pairs as needed but MUST contain 'label' and 'value' as the only required items within each object.

data/app/pb_kits/playbook/pb_dropdown/docs/_dropdown_subcomponent_structure.html.erb

@@ -0,0 +1,17 @@
+<% 
+  options = [
+    { label: 'United States', value: 'United States', id: 'us' },
+    { label: 'Canada', value: 'Canada', id: 'ca' },
+    { label: 'Pakistan', value: 'Pakistan', id: 'pk' },
+  ]
+
+%>
+
+<%= pb_rails("dropdown", props: {options: options}) do %>
+    <%= pb_rails("dropdown/dropdown_trigger") %>
+    <%= pb_rails("dropdown/dropdown_container") do %>
+        <% options.each do |option| %>
+            <%= pb_rails("dropdown/dropdown_option", props: {option: option}) %>
+        <% end %>
+    <% end %>
+<% end %>

data/app/pb_kits/playbook/pb_dropdown/docs/_dropdown_subcomponent_structure.jsx

@@ -0,0 +1,42 @@
+import React from 'react'
+import { Dropdown } from '../..'
+
+const DropdownSubcomponentStructure = (props) => {
+
+
+  const options = [
+    {
+      label: "United States",
+      value: "United States",
+    },
+    {
+      label: "Canada",
+      value: "Canada",
+    },
+    {
+      label: "Pakistan",
+      value: "Pakistan",
+    }
+  ];  
+
+
+  return (
+  <div>
+    <Dropdown
+        options={options}
+        {...props}
+    >
+      <Dropdown.Trigger/>
+      <Dropdown.Container>
+        {options.map((option) => (
+          <Dropdown.Option key={option.id} 
+              option={option}
+          />
+        ))}
+      </Dropdown.Container>
+    </Dropdown>
+  </div>
+  )
+}
+
+export default  DropdownSubcomponentStructure

data/app/pb_kits/playbook/pb_dropdown/docs/_dropdown_subcomponent_structure.md

@@ -0,0 +1,7 @@
+The dropdown comes with the following subcomponents that can be used to achieve various levels of customization:
+
+`Dropdown. Trigger` / `dropdown/dropdown_trigger`
+`Dropdown.Container`/ `dropdown/dropdown_container`
+`Dropdown.Option` / `dropdown/dropdown_option`
+
+See the code snippet below for a visual on how to use the kit with subcomponents. Each subcomponent allows for GlobalProps in addition to any subcomponent specfic props. 

data/app/pb_kits/playbook/pb_dropdown/docs/_dropdown_with_autocomplete.jsx

@@ -0,0 +1,84 @@
+import React from 'react'
+import { Dropdown, User, Badge, FlexItem } from '../..'
+
+const DropdownWithAutocomplete = (props) => {
+
+  const options = [
+    {
+      label: "Jasper Furniss",
+      value: "Jasper Furniss",
+      territory: "PHL",
+      title: "Senior UX Engineer",
+      id: "jasper-furniss",
+      status: "Offline"
+    },
+    {
+      label: "Ramon Ruiz",
+      value: "Ramon Ruiz",
+      territory: "PHL",
+      title: "Senior UX Designer",
+      id: "ramon-ruiz",
+      status: "Away"
+    },
+    {
+      label: "Jason Cypret",
+      value: "Jason Cypret",
+      territory: "PHL",
+      title: "VP of User Experience",
+      id: "jason-cypret",
+      status: "Online"
+    },
+    {
+      label: "Courtney Long",
+      value: "Courtney Long",
+      territory: "PHL",
+      title: "UX Design Mentor",
+      id: "courtney-long",
+      status: "Online"
+    }
+  ];
+
+
+  return (
+  <div>
+    <Dropdown autocomplete
+        options={options}
+        {...props}
+    >
+        {options.map((option) => (
+          <Dropdown.Option key={option.id} 
+              option={option}
+          >
+            <>
+              <FlexItem>
+                <User
+                    align="left"
+                    avatar
+                    name={option.label}
+                    orientation="horizontal"
+                    territory={option.territory}
+                    title={option.title}
+                />
+              </FlexItem>
+              <FlexItem>
+                <Badge
+                    rounded
+                    text={option.status}
+                    variant={`${
+                        option.status === "Offline"
+                        ? "neutral"
+                        : option.status === "Online"
+                        ? "success"
+                        : "warning"
+                    }`}
+                />
+              </FlexItem>
+            </>
+          </Dropdown.Option>
+        ))}
+    </Dropdown>
+  </div>
+  )
+}
+
+export default  DropdownWithAutocomplete

data/app/pb_kits/playbook/pb_dropdown/docs/_dropdown_with_autocomplete.md

@@ -0,0 +1 @@
+The `autocomplete` prop can be used to add autocomplete or typeahead functionality to the Dropdown's default Trigger. This prop is set to 'false' by default.