@pareto-engineering/design-system 4.0.0-alpha.9 → 4.0.0

package/src/ui/f/fields/RatingsInput/styles.scss

@@ -1,6 +1,8 @@
 /* @pareto-engineering/generator-front 1.0.12 */
 
 @use "@pareto-engineering/bem";
+@use "@pareto-engineering/styles/src/mixins";
+@use "@pareto-engineering/styles/src/globals" as *;
 
 $default-rating-icon-margin: .5em;
 $default-padding: .2em;
@@ -9,29 +11,26 @@ $default-transition: all .2s;
 .#{bem.$base}.ratings-input {
   display: flex;
   flex-direction: column;
+  gap: var(--gap);
 
-  p {
-    padding: $default-padding;
-  }
-
-  .stars {
+  >.stars {
     display: flex;
 
     >:not(:last-child) {
       margin-right: $default-rating-icon-margin;
     }
 
-    .#{bem.$base}.rating {
+    > .#{bem.$base}.rating {
       display: flex;
 
-      input {
+      > input {
         opacity: 0;
         position: absolute;
         visibility: none;
         z-index: -1;
       }
 
-      label {
+      > label {
         align-items: center;
         cursor: pointer;
         display: flex;
@@ -47,5 +46,3 @@ $default-transition: all .2s;
     }
   }
 }
-
-

package/src/ui/f/fields/SelectInput/SelectInput.jsx

@@ -1,17 +1,15 @@
 /* @pareto-engineering/generator-front 1.0.12 */
 import * as React from 'react'
 
-import { useInsertionEffect, memo } from 'react'
-
-import { useField } from 'formik'
+import { memo } from 'react'
 
 import PropTypes from 'prop-types'
 
 import styleNames from '@pareto-engineering/bem/exports'
 
-import { LoadingCircle } from 'ui/a'
+import './styles.scss'
 
-import { FormLabel, FormDescription } from '../../common'
+import { Single, Multiple } from './common'
 
 // Local Definitions
 
@@ -28,70 +26,53 @@ const SelectInput = ({
   style,
   name,
   label,
+  labelColor,
   color,
   options,
+  hasDefault,
   validate,
   optional,
   description,
   disabled,
   isLoading,
   autoComplete,
+  placeholder,
+  getTagColor,
+  multiple,
   // ...otherProps
 }) => {
-  useInsertionEffect(() => {
-    import('./styles.scss')
-  }, [])
-
-  const [field] = useField({ name, validate })
+  const inputProps = {
+    name,
+    label,
+    labelColor,
+    color,
+    options,
+    hasDefault,
+    validate,
+    optional,
+    description,
+    disabled,
+    isLoading,
+    placeholder,
+    getTagColor,
+    autoComplete,
+  }
+
+  const Input = multiple ? Multiple : Single
 
   return (
     <div
       id={id}
       className={[
-
         baseClassName,
-
         componentClassName,
         userClassName,
-        `y-${color}`,
       ]
         .filter((e) => e)
         .join(' ')}
       style={style}
-      // {...otherProps}
     >
-      <FormLabel name={name} optional={optional}>{label}</FormLabel>
-      <div className="select-wrapper with-faded-border">
-        <select
-          className="input"
-          {...field}
-          value={field.value || ''}
-          id={name}
-          disabled={disabled}
-          autoComplete={autoComplete}
-        >
-          {
-        options.map((option) => {
-          // i.e if option is a string like "blah", return { value: "blah", label: "blah" }
-          const newOption = typeof option === 'string' ? { value: option, label: option } : option
-
-          return (
-            <option
-              key={newOption.value}
-              value={newOption.value}
-              disabled={newOption?.disabled || false}
-            >
-              {newOption.label}
-            </option>
-          )
-        })
-      }
-        </select>
-        {isLoading && (
-        <LoadingCircle className="x-main2" />
-        )}
-      </div>
-      <FormDescription className="v50 mt-v s-1" description={description} name={name} />
+      <Input {...inputProps} />
     </div>
   )
 }
@@ -155,6 +136,11 @@ SelectInput.propTypes = {
    */
   color:PropTypes.string,
 
+  /**
+   * The color of the select input label
+   */
+  labelColor:PropTypes.string,
+
   /*
   * Whether the query that is fetching the select options is still in flight
   */
@@ -168,11 +154,27 @@ SelectInput.propTypes = {
   * Whether the input is optional or not
   */
   optional:PropTypes.bool,
+
+  /**
+   * Whether the select input should allow multiple selections
+   */
+  multiple:PropTypes.bool,
+
+  /**
+   * The placeholder of the select input
+   */
+  placeholder:PropTypes.string,
+
+  /**
+   * Whether this select input has a default value(s)
+   */
+  hasDefault:PropTypes.bool,
 }
 
 SelectInput.defaultProps = {
-  disabled:false,
-  color   :'interactive',
+  disabled  :false,
+  multiple  :false,
+  hasDefault:false,
 }
 
 export default memo(SelectInput)

package/src/ui/f/fields/SelectInput/common/Menu/Menu.jsx

@@ -0,0 +1,103 @@
+/* @pareto-engineering/generator-front 1.0.12 */
+import * as React from 'react'
+
+import PropTypes from 'prop-types'
+
+import styleNames from '@pareto-engineering/bem/exports'
+
+// Local Definitions
+
+const baseClassName = styleNames.base
+
+const componentClassName = 'menu'
+
+/**
+ * This is the component description.
+ */
+const Menu = React.forwardRef(({
+  id,
+  className:userClassName,
+  style,
+  items,
+  isOpen,
+  highlightedIndex,
+  getItemProps,
+  ...otherProps
+}, ref) => (
+  <ul
+    id={id}
+    className={[
+
+      baseClassName,
+
+      componentClassName,
+      userClassName,
+    ]
+      .filter((e) => e)
+      .join(' ')}
+    style={style}
+    ref={ref}
+    {...otherProps}
+  >
+    {isOpen && items.map((item, index) => (
+      <li
+        key={item.label}
+        {...getItemProps({ item, index })}
+        className={[
+          'item',
+          highlightedIndex === index && styleNames.modifierActive,
+        ].filter(Boolean)
+          .join(' ')}
+      >
+        <p>
+          {item.label}
+        </p>
+      </li>
+    ))}
+  </ul>
+))
+Menu.propTypes = {
+  /**
+   * The HTML id for this element
+   */
+  id:PropTypes.string,
+
+  /**
+   * The HTML class names for this element
+   */
+  className:PropTypes.string,
+
+  /**
+   * The React-written, css properties for this element.
+   */
+  style:PropTypes.objectOf(PropTypes.string),
+
+  /**
+   *  The items to be displayed in the menu
+   */
+  items:PropTypes.arrayOf(PropTypes.shape({
+    value:PropTypes.string,
+    label:PropTypes.string,
+  })),
+
+  /**
+   * Whether or not the menu is open
+   */
+  isOpen:PropTypes.bool,
+
+  /**
+   * The index of the highlighted item
+   */
+  highlightedIndex:PropTypes.number,
+
+  /**
+   * The function to get the item props
+   */
+  getItemProps:PropTypes.func,
+}
+
+Menu.defaultProps = {
+  // someProp:false
+}
+
+export default Menu

package/{dist/es/c/ContentSlides/common/Slide → src/ui/f/fields/SelectInput/common/Menu}/index.js

@@ -1,2 +1,2 @@
 /* @pareto-engineering/generator-front 1.0.12 */
-export { default as Slide } from "./Slide";
+export { default as Menu } from './Menu'

package/src/ui/f/fields/SelectInput/common/Multiple/Multiple.jsx

@@ -0,0 +1,288 @@
+/* @pareto-engineering/generator-front 1.0.12 */
+import * as React from 'react'
+
+import {
+  useState, useEffect, useMemo, useRef,
+} from 'react'
+
+import { useField } from 'formik'
+
+import PropTypes from 'prop-types'
+
+import { useCombobox, useMultipleSelection } from 'downshift'
+
+import styleNames from '@pareto-engineering/bem/exports'
+
+import { Button } from 'ui/b'
+
+import { Popover } from 'ui/a'
+
+import { FormDescription, FormLabel } from 'ui/f'
+
+import { Menu } from '../Menu'
+
+// Local Definitions
+
+const baseClassName = styleNames.base
+
+const componentClassName = 'multiple'
+
+/**
+ *  @param {Array[Object]} first - first array to check if it has an item not in the second array.
+ *  @param {Array[Object]} second - second array to check against the first array.
+ *
+ * @returns {Boolean} - true if the first array has an item not in the second array.
+ */
+const testIfArraysAreUnique = (first, second) => first
+  .filter((objInFirstArray) => !second
+    .some((objInSecondArray) => objInFirstArray.value === objInSecondArray.value))
+  .length > 0
+
+/**
+ * This is the component description.
+ */
+const Multiple = ({
+  id,
+  className:userClassName,
+  style,
+  name,
+  label,
+  labelColor,
+  color,
+  options,
+  validate,
+  optional,
+  description,
+  disabled,
+  autoComplete,
+  transformSearch,
+  getTagColor,
+  placeholder,
+  // ...otherProps
+}) => {
+  const [, meta, helpers] = useField({ name, validate })
+
+  const { setValue } = helpers
+
+  const { value } = meta
+
+  const [searchInputValue, setSearchInputValue] = useState('')
+
+  const {
+    getSelectedItemProps,
+    getDropdownProps,
+    addSelectedItem,
+    removeSelectedItem,
+    setSelectedItems,
+    selectedItems,
+  } = useMultipleSelection({
+    initialSelectedItems:value || [],
+  })
+
+  /**
+   * @returns {Boolean} - Unique items from the options array so that the combobox
+   * shows only the options that are not yet selected.
+ */
+
+  const items = useMemo(() => {
+    const lowerCasedInputValue = searchInputValue.toLowerCase()
+
+    return options.filter((option) => {
+      const lowerCasedOption = option.label.toLowerCase()
+
+      return lowerCasedOption.includes(lowerCasedInputValue)
+        && !selectedItems.includes(option)
+    })
+  }, [searchInputValue, selectedItems])
+
+  const {
+    isOpen,
+    getLabelProps,
+    getMenuProps,
+    getInputProps,
+    getComboboxProps,
+    highlightedIndex,
+    getItemProps,
+  } = useCombobox({
+    inputValue             :searchInputValue,
+    defaultHighlightedIndex:0, // after selection, highlight the first item.
+    selectedItem           :null,
+    items,
+    circularNavigation     :true,
+    stateReducer           :(state, actionAndChanges) => {
+      const { changes, type } = actionAndChanges
+      switch (type) {
+        case useCombobox.stateChangeTypes.InputKeyDownEnter:
+        case useCombobox.stateChangeTypes.ItemClick:
+          return {
+            ...changes,
+            isOpen:true, // keep the menu open after selection.
+          }
+        default:
+          break
+      }
+      return changes
+    },
+    onStateChange:({ inputValue:newSearchInputValue, type, selectedItem }) => {
+      switch (type) {
+        case useCombobox.stateChangeTypes.InputChange: {
+          const transformedInput = transformSearch(newSearchInputValue)
+          setSearchInputValue(transformedInput)
+          break
+        }
+        case useCombobox.stateChangeTypes.InputKeyDownEnter:
+        case useCombobox.stateChangeTypes.ItemClick:
+        case useCombobox.stateChangeTypes.InputBlur:
+          if (selectedItem) {
+            setSearchInputValue('')
+            addSelectedItem(selectedItem)
+          }
+          break
+        default:
+          break
+      }
+    },
+  })
+
+  useEffect(() => {
+    setValue(selectedItems)
+  }, [selectedItems])
+
+  useEffect(() => {
+    if (value?.length > 0 && (
+      testIfArraysAreUnique(value, selectedItems)
+      || testIfArraysAreUnique(selectedItems, value)
+    )) {
+      setSelectedItems(value)
+    }
+  }, [value])
+
+  const parentRef = useRef(null)
+
+  return (
+    <div
+      id={id}
+      className={[
+
+        baseClassName,
+
+        componentClassName,
+        userClassName,
+      ]
+        .filter((e) => e)
+        .join(' ')}
+      style={style}
+      ref={parentRef}
+      {...getComboboxProps()}
+      // {...otherProps}
+    >
+      {label && (
+        <FormLabel
+          className={[
+            baseClassName,
+            componentClassName,
+          ]
+            .filter((e) => e)
+            .join(' ')}
+          {...getLabelProps()}
+          name={name}
+          optional={optional}
+          color={labelColor}
+        >
+          {label}
+        </FormLabel>
+      )}
+
+      {selectedItems?.length > 0 && (
+        <div className="selected-items">
+          {selectedItems.map((selectedItem, index) => (
+            <div
+              key={selectedItem.label}
+              {...getSelectedItemProps({ selectedItem, index })}
+              className="item"
+            >
+              <Button
+                onClick={(e) => {
+                  e.stopPropagation()
+                  removeSelectedItem(selectedItem)
+                }}
+                isCompact
+                color={getTagColor ? getTagColor(selectedItem) : color}
+              >
+                <span>{selectedItem.label}</span>
+                <span className="icon close">Y</span>
+              </Button>
+            </div>
+          ))}
+        </div>
+      )}
+      <div className="input-container">
+        <input
+          {...getInputProps(
+            getDropdownProps({ preventKeyAction: isOpen }),
+          )}
+          className="input"
+          disabled={disabled}
+          placeholder={placeholder}
+          autoComplete={autoComplete}
+        />
+      </div>
+
+      <FormDescription className="s-1" description={description} name={name} />
+      <Popover
+        isOpen={isOpen}
+        parentRef={parentRef}
+      >
+        <Menu
+          className={`y-${color}`}
+          isOpen={isOpen}
+          getItemProps={getItemProps}
+          highlightedIndex={highlightedIndex}
+          items={items}
+          {...getMenuProps()}
+        />
+      </Popover>
+
+    </div>
+  )
+}
+
+Multiple.propTypes = {
+  /**
+   * The HTML id for this element
+   */
+  id:PropTypes.string,
+
+  /**
+   * The HTML class names for this element
+   */
+  className:PropTypes.string,
+
+  /**
+   * The React-written, css properties for this element.
+   */
+  style:PropTypes.objectOf(PropTypes.string),
+
+  /**
+   * A function that transforms the search input value
+   */
+  transformSearch:PropTypes.func,
+
+  /**
+   * The minimum length of the search input value
+   */
+  minLength:PropTypes.number,
+
+  /**
+   * The base color of the component
+   */
+  color:PropTypes.string,
+}
+
+Multiple.defaultProps = {
+  transformSearch:(e) => e,
+  minLength      :2,
+  color          :'interactive',
+}
+
+export default Multiple

package/src/ui/f/fields/SelectInput/common/Multiple/index.js

@@ -0,0 +1,2 @@
+/* @pareto-engineering/generator-front 1.0.12 */
+export { default as Multiple } from './Multiple'