@addev-be/ui 0.2.16 → 0.2.19

package/src/components/data/DataGrid/DataGridColumnsModal/styles.ts

@@ -0,0 +1,104 @@
+import styled, { css } from 'styled-components';
+
+export const Container = styled.div.attrs({
+  className: 'DataGridColumnsModal-Container',
+})`
+  display: flex;
+  flex-direction: row;
+  gap: var(--space-2);
+  overflow: auto;
+  font-size: var(--text-base);
+  height: 100%;
+`;
+
+export const Panel = styled.div.attrs({
+  className: 'DataGridColumnsModal-Panel',
+})`
+  display: flex;
+  flex-direction: column;
+  flex: 1;
+`;
+
+export const Title = styled.div.attrs({
+  className: 'DataGridColumnsModal-Title',
+})`
+  margin: 0;
+  margin-bottom: var(--space-2);
+  font-weight: bold;
+`;
+
+export const ColumnsList = styled.ul.attrs({
+  className: 'DataGridColumnsModal-ColumnsList',
+})`
+  display: flex;
+  flex-direction: column;
+  flex: 1;
+  overflow: auto;
+  border: 1px solid var(--color-neutral-200);
+  margin: 0;
+  background-color: var(--color-neutral-50);
+
+  & > li:not(:last-child) {
+    border-bottom: 1px solid var(--color-neutral-100);
+  }
+`;
+
+export const ColumnItem = styled.li.attrs({
+  className: 'DataGridColumnsModal-ColumnItem',
+})<{
+  $visible?: boolean;
+}>`
+  padding: var(--space-1);
+  transition: background-color 0.2s;
+  cursor: pointer;
+  display: flex;
+  flex-direction: row;
+  align-items: center;
+  gap: var(--space-2);
+
+  span {
+    flex: 1;
+  }
+
+  button {
+    display: none;
+    padding: var(--space-1);
+    width: var(--space-6);
+    height: var(--space-6);
+    border-radius: var(--rounded-full);
+    background-color: var(--color-neutral-200);
+    border: none;
+    align-items: center;
+    justify-content: center;
+  }
+
+  &:hover {
+    background-color: var(--color-neutral-100);
+    button {
+      display: flex;
+      background-color: var(--color-neutral-300);
+    }
+  }
+`;
+
+export const Buttons = styled.div.attrs({
+  className: 'DataGridColumnsModal-Buttons',
+})<{ $visible?: boolean }>`
+  display: flex;
+  gap: var(--space-1);
+  height: var(--space-6);
+  ${({ $visible }) =>
+    $visible
+      ? css`
+          width: var(--space-24);
+          justify-content: flex-end;
+        `
+      : css`
+          width: var(--space-6);
+        `}
+
+  svg {
+    width: var(--space-4);
+    height: var(--space-4);
+  }
+`;

package/src/components/data/DataGrid/DataGridEditableCell.tsx

@@ -0,0 +1,43 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unnecessary-type-constraint */
+
+import { useCallback, useState } from 'react';
+
+import { DataGridCellProps } from './types';
+import { useDataGridContext } from './hooks';
+
+export const DataGridEditableCell = <R,>({
+  row,
+  columnKey,
+  column,
+  context,
+}: DataGridCellProps<R>) => {
+  const { onCellEdited, setEditingCell } = useDataGridContext(context);
+  const [value, setValue] = useState(
+    column.getter
+      ? column.getter(row)
+      : column.propertyName
+      ? String(row[column.propertyName])
+      : ''
+  );
+
+  const onClose = useCallback(() => {
+    onCellEdited?.(row, columnKey, value);
+    setEditingCell([-1, -1]);
+  }, [columnKey, onCellEdited, row, setEditingCell, value]);
+
+  return (
+    <td key={columnKey}>
+      <input
+        type="text"
+        // className="relative  z-10 block text-normal w-full border-0 py-1.5 text-gray-900 ring-1 ring-inset ring-gray-300 placeholder:text-gray-400 focus:ring-2 focus:ring-inset focus:ring-sky-600 sm:text-sm sm:leading-6"
+        value={String(value)}
+        onChange={(e) => setValue(e.target.value)}
+      />
+      <div
+        // className="fixed inset-0 bg-black bg-opacity-10"
+        onClick={onClose}
+      />
+    </td>
+  );
+};

package/src/components/data/DataGrid/DataGridFilterMenu/FilterValuesScroller.tsx

@@ -0,0 +1,120 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import * as styles from './styles';
+
+import {
+  DataGridFilterCheckbox,
+  DataGridFilterFormatter,
+  DataGridFilterGroup,
+  DataGridFilterRenderer,
+  DataGridFilterValue,
+} from '../types';
+import { defaultRendererAndFormatter, getCheckboxes } from '../helpers';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+
+import { debounce } from 'lodash';
+import { useElementSize } from '../../../../hooks';
+
+const CheckboxTemplate = ({
+  selectedValues,
+  value,
+  index,
+  style,
+  onToggle,
+}: {
+  selectedValues: DataGridFilterValue[];
+  value: DataGridFilterCheckbox;
+  index: number;
+  style?: React.CSSProperties;
+  onToggle?: (values: DataGridFilterValue[]) => void;
+}) => {
+  const checked = useMemo(
+    () => value.values.every((v) => selectedValues.includes(v)),
+    [selectedValues, value.values]
+  );
+  return (
+    <styles.FilterValueContainer
+      key={index}
+      style={{ ...style, paddingLeft: `${value.level}rem` }}
+      title={value.title}
+      onClick={() => onToggle?.(value.values)}
+    >
+      <input type="checkbox" checked={checked} readOnly />
+      <span>{value.displayValue || '(Vides)'}</span>
+    </styles.FilterValueContainer>
+  );
+};
+
+type FilterValuesScrollerProps = {
+  values: DataGridFilterValue[];
+  rowHeight?: number;
+  formatter: DataGridFilterFormatter;
+  renderer: DataGridFilterRenderer;
+  onRangeChange?: (startIndex: number, length: number) => void;
+  onToggle?: (values: DataGridFilterValue[]) => void;
+  selectedValues?: DataGridFilterValue[];
+  groups?: DataGridFilterGroup[];
+};
+
+export const FilterValuesScroller = ({
+  values,
+  rowHeight = styles.DEFAULT_FILTER_ROW_HEIGHT,
+  onRangeChange,
+  onToggle,
+  formatter = defaultRendererAndFormatter,
+  renderer = defaultRendererAndFormatter,
+  selectedValues = [],
+  groups,
+}: FilterValuesScrollerProps) => {
+  const scrollableRef = useRef<HTMLDivElement | null>(null);
+  const { height } = useElementSize(scrollableRef.current);
+
+  const tolerance = 20;
+  const [scrollTop, setScrollTop] = useState(0);
+  const index = Math.floor(scrollTop / rowHeight);
+  const length = Math.ceil(height / rowHeight);
+
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  const onScroll = useCallback(
+    debounce((e: React.UIEvent<HTMLDivElement>) => {
+      const target = e.target as HTMLDivElement;
+      setScrollTop(() => target.scrollTop);
+    }, 50),
+    []
+  );
+
+  const checkboxes = useMemo(
+    () => getCheckboxes(values, '', renderer, formatter, groups),
+    [values, groups, renderer, formatter]
+  );
+  const visibleCheckboxes = checkboxes.slice(
+    Math.max(0, index - tolerance),
+    index + length + 1 + tolerance
+  );
+  const firstCheckboxTop = Math.max(0, index - tolerance) * rowHeight;
+
+  useEffect(() => {
+    onRangeChange?.(index, length);
+  }, [index, length, onRangeChange]);
+
+  return (
+    <styles.FilterValuesScrollerContainer
+      ref={scrollableRef}
+      onScroll={onScroll}
+      $rowHeight={rowHeight}
+    >
+      <div style={{ height: `${checkboxes.length * rowHeight}px` }}>
+        {visibleCheckboxes.map((value, index) => (
+          <CheckboxTemplate
+            style={{ top: firstCheckboxTop + index * rowHeight + 'px' }}
+            key={index}
+            selectedValues={selectedValues}
+            value={value}
+            index={index}
+            onToggle={onToggle}
+          />
+        ))}
+      </div>
+    </styles.FilterValuesScrollerContainer>
+  );
+};

package/src/components/data/DataGrid/DataGridFilterMenu/hooks.tsx

@@ -0,0 +1,75 @@
+import { DataGridContext, DataGridFilter } from '../types';
+import { FilterIcon, FilterSlashIcon } from '../../../../Icons';
+import { useCallback, useState } from 'react';
+
+import { Button } from '../../../forms';
+import { FilterModalContent } from '../FilterModalContent';
+import { Modal } from '../../../layout/Modal';
+import { useDataGridContext } from '../hooks';
+
+export const useFilterModal = <R,>({
+  columnKey,
+  context,
+}: {
+  columnKey: string;
+  context: DataGridContext<R>;
+}) => {
+  const [isVisible, setIsVisible] = useState(false);
+  const { filters = {}, columns, setFilters } = useDataGridContext<R>(context);
+  const column = columns[columnKey];
+  const [currentFilter, setCurrentFilter] = useState<DataGridFilter>(
+    filters[columnKey] ?? column?.filter
+  );
+
+  const openModal = useCallback(() => {
+    setIsVisible(true);
+  }, []);
+  const closeModal = useCallback(() => {
+    setIsVisible(false);
+  }, []);
+
+  const onClearClicked = useCallback(() => {
+    const newFilters = { ...filters };
+    delete newFilters[columnKey];
+    setFilters(newFilters);
+    closeModal();
+  }, [closeModal, columnKey, filters, setFilters]);
+
+  const onApplyClicked = useCallback(() => {
+    setFilters({ ...filters, [columnKey]: currentFilter });
+    closeModal();
+  }, [closeModal, columnKey, currentFilter, filters, setFilters]);
+
+  const onCancelClicked = useCallback(() => {
+    closeModal();
+  }, [closeModal]);
+
+  const modal = isVisible ? (
+    <Modal>
+      <Modal.Header>Filtrer "{column.name}"</Modal.Header>
+      <Modal.ContentWithIcon>
+        <FilterIcon fill="var(--color-primary-400)" />
+        <FilterModalContent
+          filter={currentFilter}
+          onFilterChanged={setCurrentFilter}
+        />
+      </Modal.ContentWithIcon>
+      <Modal.Buttons>
+        <Button color="danger" icon={FilterSlashIcon} onClick={onClearClicked}>
+          Supprimer
+        </Button>
+        <Button
+          style={{ marginLeft: 'auto' }}
+          color="primary"
+          icon={FilterIcon}
+          onClick={onApplyClicked}
+        >
+          Filtrer
+        </Button>
+        <Button onClick={onCancelClicked}>Annuler</Button>
+      </Modal.Buttons>
+    </Modal>
+  ) : null;
+
+  return { openModal, closeModal, modal };
+};

package/src/components/data/DataGrid/DataGridFilterMenu/index.tsx

@@ -0,0 +1,360 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unnecessary-type-constraint */
+
+import * as styles from './styles';
+
+import {
+  ArrowDown19Icon,
+  ArrowDownAZIcon,
+  ArrowDownBigSmallIcon,
+  ArrowUp91Icon,
+  ArrowUpBigSmallIcon,
+  ArrowUpZAIcon,
+  FilterIcon,
+  FilterSlashIcon,
+  IconFC,
+  MagnifierIcon,
+  SigmaIcon,
+  SortCalendarAscendingIcon,
+  SortCalendarDescendingIcon,
+  TableFooterIcon,
+  TableFooterSlashIcon,
+  TallyIcon,
+  XBarIcon,
+} from '../../../../Icons';
+import {
+  DataGridContext,
+  DataGridFilterType,
+  DataGridFilterValue,
+  DataGridFooterPredefinedFunction,
+} from '../types';
+import {
+  applyFilters,
+  defaultRendererAndFormatter,
+  getDateGroups,
+} from '../helpers';
+import { intersection, uniq, without } from 'lodash';
+import {
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+
+import { ContextMenu } from '../../../ui/ContextMenu';
+import { FilterValuesScroller } from './FilterValuesScroller';
+import { Input } from '../../../forms';
+import { useFilterModal } from './hooks';
+
+type FilterValuesProps<R> = {
+  columnKey: string;
+  columnIndex: number;
+  context: DataGridContext<R>;
+  onClose?: () => void;
+};
+
+const sortAsc: Record<DataGridFilterType, [string, IconFC]> = {
+  number: ['Trier du plus petit au plus grand', ArrowDown19Icon],
+  text: ['Trier de A à Z', ArrowDownAZIcon],
+  date: ['Trier du plus ancien au plus récent', SortCalendarAscendingIcon],
+};
+const sortDesc: Record<DataGridFilterType, [string, IconFC]> = {
+  number: ['Trier du plus grand au plus petit', ArrowUp91Icon],
+  text: ['Trier de Z à A', ArrowUpZAIcon],
+  date: ['Trier du plus récent au plus ancien', SortCalendarDescendingIcon],
+};
+
+const footerFunctionsTexts: Record<DataGridFooterPredefinedFunction, string> = {
+  average: 'Moyenne',
+  avg: 'Moyenne',
+  count: 'Nombre',
+  max: 'Maximum',
+  min: 'Minimum',
+  sum: 'Somme',
+};
+const footerFunctionsIcons: Record<DataGridFooterPredefinedFunction, IconFC> = {
+  average: XBarIcon,
+  avg: XBarIcon,
+  count: TallyIcon,
+  max: ArrowUpBigSmallIcon,
+  min: ArrowDownBigSmallIcon,
+  sum: SigmaIcon,
+};
+
+export const DataGridFilterMenu = <R,>({
+  columnKey,
+  context,
+  onClose,
+}: FilterValuesProps<R>) => {
+  const { openModal, modal } = useFilterModal({ columnKey, context });
+  const {
+    filters = {},
+    footers = {},
+    rows,
+    columns,
+    setFilters,
+    filterValuesLoader,
+    setSorts,
+    setFooters,
+  } = useContext(context);
+  const column = columns[columnKey] ?? {};
+  const textFilterInputRef = useRef<HTMLInputElement>(null);
+  const [textFilter, setTextFilter] = useState('');
+
+  const [availableValues, setAvailableValues] = useState<DataGridFilterValue[]>(
+    []
+  );
+
+  useEffect(() => {
+    if (filterValuesLoader) {
+      filterValuesLoader(columnKey).then((values) => {
+        setAvailableValues(() => values);
+      });
+    } else {
+      const otherFilters = Object.entries(filters)
+        .filter(([key]) => key !== columnKey)
+        .map(([, filter]) => filter);
+      const availableRows = applyFilters(rows, otherFilters);
+      const values = availableRows.map((row) => column.filter!.getter(row));
+      setAvailableValues(() =>
+        uniq(values).sort(
+          column.filter?.type === 'number'
+            ? (a, b) => (a as number) - (b as number)
+            : (a, b) => (a as string).localeCompare(b as string)
+        )
+      );
+    }
+  }, [column.filter, columnKey, filterValuesLoader, filters, rows]);
+
+  const selectedValues = useMemo(
+    () => filters?.[columnKey]?.values ?? [],
+    [columnKey, filters]
+  );
+
+  const clearFilter = useCallback(() => {
+    const newFilters = { ...filters };
+    delete newFilters[columnKey];
+    setFilters(newFilters);
+    onClose?.();
+  }, [filters, columnKey, setFilters, onClose]);
+
+  const setValuesChecked = useCallback(
+    (values: any[], checked?: boolean) => {
+      setFilters((prevFilters) => {
+        const newValues = checked
+          ? [...(prevFilters[columnKey]?.values ?? []), ...values]
+          : without(prevFilters[columnKey]?.values ?? [], ...values);
+        const newFilters = {
+          ...prevFilters,
+        };
+        if (newValues.length === 0) {
+          delete newFilters[columnKey];
+        } else {
+          newFilters[columnKey] = {
+            ...(prevFilters[columnKey] ?? column.filter),
+            operator: 'inArray',
+            values: newValues,
+          };
+        }
+        return newFilters;
+      });
+    },
+    [setFilters, columnKey, column.filter]
+  );
+
+  const toggleValues = useCallback(
+    (values: DataGridFilterValue[]) => {
+      const checked =
+        intersection(selectedValues, values).length === values.length;
+      setValuesChecked(values, !checked);
+    },
+    [setValuesChecked, selectedValues]
+  );
+
+  const formatter = useMemo(
+    () => column.filter?.formatter ?? defaultRendererAndFormatter,
+    [column.filter?.formatter]
+  );
+  const renderer = useMemo(
+    () => column.filter?.renderer ?? defaultRendererAndFormatter,
+    [column.filter?.renderer]
+  );
+
+  const filteredAvailableValues = useMemo(
+    () =>
+      !textFilter
+        ? availableValues
+        : availableValues.filter((value) =>
+            formatter(value)?.toLowerCase().includes(textFilter.toLowerCase())
+          ),
+    [availableValues, formatter, textFilter]
+  );
+
+  useEffect(() => {
+    if (textFilterInputRef.current) {
+      textFilterInputRef.current.focus();
+    }
+  }, []);
+
+  const checkboxesComponent = useMemo(() => {
+    const groups =
+      column.type === 'date'
+        ? getDateGroups(filteredAvailableValues)
+        : undefined;
+    return (
+      <FilterValuesScroller
+        values={filteredAvailableValues}
+        selectedValues={selectedValues}
+        onToggle={toggleValues}
+        formatter={formatter}
+        renderer={renderer}
+        groups={groups}
+      />
+    );
+  }, [
+    column.type,
+    filteredAvailableValues,
+    formatter,
+    renderer,
+    selectedValues,
+    toggleValues,
+  ]);
+
+  const onSortAscClicked = useCallback(() => {
+    setSorts({ [columnKey]: 'asc' });
+    onClose?.();
+  }, [columnKey, onClose, setSorts]);
+  const onSortDescClicked = useCallback(() => {
+    setSorts({ [columnKey]: 'desc' });
+    onClose?.();
+  }, [columnKey, onClose, setSorts]);
+
+  const hasFilters = filters[columnKey]?.values.length > 0;
+  const [[sortAscText, SortAscIcon], [sortDescText, SortDescIcon]] = [
+    sortAsc[column.filter?.type ?? 'text'],
+    sortDesc[column.filter?.type ?? 'text'],
+  ];
+
+  const isFooterVisible =
+    columnKey in footers && footers[columnKey] !== undefined;
+  const showFooter = useCallback(
+    (key: string) => {
+      setFooters((prevFooters) => ({
+        ...prevFooters,
+        [columnKey]: key,
+      }));
+      onClose?.();
+    },
+    [columnKey, onClose, setFooters]
+  );
+  const hideFooter = useCallback(() => {
+    setFooters((prevFooters) => {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const { [columnKey]: _, ...newFooters } = prevFooters;
+      return newFooters;
+    });
+    onClose?.();
+  }, [columnKey, onClose, setFooters]);
+
+  return (
+    <ContextMenu>
+      {modal}
+      {column.sortGetter && (
+        <>
+          <ContextMenu.Item onClick={onSortAscClicked}>
+            <SortAscIcon />
+            {sortAscText}
+          </ContextMenu.Item>
+          <ContextMenu.Item onClick={onSortDescClicked}>
+            <SortDescIcon />
+            {sortDescText}
+          </ContextMenu.Item>
+          <ContextMenu.Divider />
+        </>
+      )}
+      {isFooterVisible && typeof column.footer === 'function' && (
+        <>
+          <ContextMenu.Item onClick={hideFooter}>
+            <TableFooterSlashIcon />
+            Masquer le total
+          </ContextMenu.Item>
+          <ContextMenu.Divider />
+        </>
+      )}
+      {!isFooterVisible && typeof column.footer === 'function' && (
+        <>
+          <ContextMenu.Item onClick={() => showFooter('count')}>
+            <TableFooterIcon />
+            Afficher le total
+          </ContextMenu.Item>
+          <ContextMenu.Divider />
+        </>
+      )}
+      {typeof column.footer === 'object' && (
+        <>
+          <ContextMenu.ParentItem>
+            <TableFooterIcon />
+            Afficher le total
+            <ContextMenu.SubMenu>
+              {Object.keys(column.footer).map((key) => {
+                const TotalIcon =
+                  footerFunctionsIcons[
+                    key as DataGridFooterPredefinedFunction
+                  ] ?? TableFooterIcon;
+                return (
+                  <ContextMenu.Item key={key} onClick={() => showFooter(key)}>
+                    <TotalIcon />
+                    {key in footerFunctionsTexts
+                      ? footerFunctionsTexts[
+                          key as DataGridFooterPredefinedFunction
+                        ]
+                      : key}
+                  </ContextMenu.Item>
+                );
+              })}
+              <ContextMenu.Divider />
+              <ContextMenu.Item
+                onClick={hideFooter}
+                disabled={!isFooterVisible}
+              >
+                <TableFooterSlashIcon />
+                Masquer le total
+              </ContextMenu.Item>
+            </ContextMenu.SubMenu>
+          </ContextMenu.ParentItem>
+          <ContextMenu.Divider />
+        </>
+      )}
+      <ContextMenu.Item onClick={openModal}>
+        <FilterIcon />
+        Filtrer ...
+      </ContextMenu.Item>
+      <ContextMenu.Item
+        $color="danger"
+        onClick={clearFilter}
+        disabled={!hasFilters}
+      >
+        <FilterSlashIcon />
+        Supprimer le filtre
+      </ContextMenu.Item>
+      <ContextMenu.Divider />
+      <styles.InputContainer>
+        <MagnifierIcon />
+        <Input
+          ref={textFilterInputRef}
+          type="text"
+          name="search"
+          id="search"
+          placeholder="Rechercher ..."
+          value={textFilter}
+          onChange={(e) => setTextFilter(e.target.value)}
+        />
+      </styles.InputContainer>
+      <styles.CheckboxesContainer>
+        {checkboxesComponent}
+      </styles.CheckboxesContainer>
+    </ContextMenu>
+  );
+};