rbro-tat-uds 1.6.36 → 2.0.0

package/build/cjs/components/Datepicker/Calendar.cjs

@@ -0,0 +1,453 @@
+"use strict";
+"use client";
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var styled = require('styled-components');
+var Button = require('../Button/Button.cjs');
+var IconButton = require('../IconButton/IconButton.cjs');
+var utils = require('../../utils');
+var helpers_calendar = require('./helpers_calendar.cjs');
+
+const CalendarContainer = styled.div`
+  border-radius: 16px;
+  background-color: ${utils.colors.white};
+  box-shadow: 0px 6px 20px 0px rgba(19, 20, 22, 0.2),
+    0px 2px 6px 0px rgba(19, 20, 22, 0.15);
+  overflow: hidden;
+`;
+const CalendarHeader = styled.div`
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 4px;
+  padding: 12px;
+
+  & > div {
+    & > button {
+      cursor: pointer;
+      background-color: transparent;
+      outline: none;
+      border: none;
+      font-size: 14px;
+      font-weight: 500;
+      line-height: 120%;
+      color: ${utils.colors.info_800};
+    }
+  }
+
+  & > select {
+    outline: none;
+    height: 32px;
+    padding: 0px 12px;
+    background-color: transparent;
+    border-radius: 9999px;
+    border: 1px solid #8f919952;
+    cursor: pointer;
+    font-size: 14px;
+    font-weight: 400;
+    line-height: 171%;
+  }
+`;
+const CalendarFooter = styled.div`
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 12px;
+  justify-content: space-between;
+`;
+const CalendarGrid = styled.div`
+  border-top: 1px solid ${utils.colors.gray_150};
+  border-bottom: 1px solid ${utils.colors.gray_150};
+  padding: 12px;
+  display: grid;
+  grid-template: ${({ $view }) => $view === "date" ? "repeat(7, auto) / repeat(7, auto)" : "repeat(6,auto) / repeat(4,auto)"};
+  row-gap: 6px;
+  column-gap: 6px;
+`;
+const CalendarCell = styled.div`
+  width: 36px;
+  height: 36px;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  text-align: center;
+  user-select: none;
+  grid-column: ${({ $index }) => $index % 7 + 1} / span 1;
+`;
+const CalendarDay = styled(CalendarCell)`
+  font-size: 14px;
+  font-weight: 400;
+  line-height: 171%;
+  color: ${utils.colors.gray_200};
+`;
+const CalendarDate = styled(CalendarCell)`
+  font-weight: 400;
+  font-size: 14px;
+  cursor: pointer;
+  color: ${({ $inMonth, $isLimited }) => $isLimited ? utils.colors.gray_200 : $inMonth ? utils.colors.gray_950 : utils.colors.gray_200};
+
+  grid-row: ${({ $index }) => Math.floor($index / 7) + 2} / span 1;
+  transition: all 0.4s ease-out;
+  :hover {
+    color: #06c;
+    background: rgba(0, 102, 204, 0.075);
+  }
+`;
+const HighlightedCalendarDate = styled(CalendarDate)`
+  color: #fff;
+  background: ${utils.colors.info_600} !important;
+  border-radius: 9999px;
+  position: relative;
+`;
+const TodayCalendarDate = styled(HighlightedCalendarDate)`
+  background: transparent !important;
+  border-radius: 9999px;
+  border: 1px solid ${utils.colors.gray_100};
+  color: ${({ $isLimited }) => $isLimited ? utils.colors.gray_200 : utils.colors.gray_950};
+`;
+const CalendarNonDateCell = styled.div`
+  width: 67.5px;
+  height: 40px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  text-align: center;
+  user-select: none;
+`;
+const CalendarNonDate = styled(CalendarNonDateCell)`
+  font-size: 14px;
+  font-weight: 400;
+  line-height: 120%;
+  color: ${utils.colors.gray_950};
+  cursor: pointer;
+`;
+const HighlightedCalendarNonDate = styled(CalendarNonDate)`
+  color: #fff;
+  background: ${utils.colors.info_600} !important;
+  border-radius: 9999px;
+  position: relative;
+`;
+const CurrentCalendarNonDate = styled(HighlightedCalendarNonDate)`
+  background: transparent !important;
+  border-radius: 9999px;
+  border: 1px solid ${utils.colors.gray_100};
+  color: ${utils.colors.gray_950};
+`;
+const Calendar = ({
+  date,
+  onDateChanged,
+  setCalendarOpen,
+  limitStart,
+  limitEnd
+}) => {
+  const [dateState, setDateState] = React.useState({
+    current: date,
+    month: +date.getMonth() + 1,
+    year: date.getFullYear()
+  });
+  const [view, setView] = React.useState("date");
+  const addDateToState = (date2) => {
+    const isDateObject = helpers_calendar.isDate(date2);
+    const _date = isDateObject ? date2 : /* @__PURE__ */ new Date();
+    setDateState({
+      current: date2,
+      month: +_date.getMonth() + 1,
+      year: _date.getFullYear()
+    });
+  };
+  const renderMonthAndYear = React.useMemo(() => {
+    const { month, year } = dateState;
+    const monthname = Object.keys(helpers_calendar.CALENDAR_MONTHS)[Math.max(0, Math.min(month - 1, 11))];
+    return {
+      monthname: helpers_calendar.CALENDAR_MONTHS[monthname],
+      year
+    };
+  }, [dateState]);
+  const gotoDate = (date2, event) => {
+    event && event.preventDefault();
+    const { current } = dateState;
+    if (!(current && helpers_calendar.isSameDay(date2, current))) {
+      addDateToState(date2);
+      onDateChanged && onDateChanged(date2);
+    }
+  };
+  const gotoYear = (year, event) => {
+    event && event.preventDefault();
+    setDateState({
+      current: dateState.current,
+      month: dateState.month,
+      year: +year
+    });
+    setView("month");
+  };
+  const gotoMonth = (month, event) => {
+    event && event.preventDefault();
+    setDateState({
+      current: dateState.current,
+      month: +month,
+      year: dateState.year
+    });
+    setView("date");
+  };
+  const renderDayLabel = (day, index) => {
+    const daylabel = helpers_calendar.WEEK_DAYS[day].toUpperCase();
+    return /* @__PURE__ */ jsxRuntime.jsx(CalendarDay, { $index: index, children: daylabel }, daylabel + index);
+  };
+  const getCalendarDates = () => {
+    const { current, month, year } = dateState;
+    const calendarMonth = month || +current?.getMonth() + 1;
+    const calendarYear = year || current?.getFullYear();
+    return helpers_calendar.default(calendarMonth, calendarYear);
+  };
+  const isValidDateFormatLimit = (dateString) => {
+    const regex = /^\d{4}-\d{2}-\d{2}$/;
+    if (!regex.test(dateString)) return false;
+    const date2 = new Date(dateString);
+    const getTimestamp = date2.getTime();
+    if (isNaN(getTimestamp)) return false;
+    const [year, month, day] = dateString.split("-");
+    const check_year = date2.getUTCFullYear() !== parseInt(year, 10);
+    if (check_year) return false;
+    const check_month = date2.getUTCMonth() + 1 !== parseInt(month, 10);
+    if (check_month) return false;
+    const check_day = date2.getUTCDate() !== parseInt(day, 10);
+    if (check_day) return false;
+    return true;
+  };
+  const checkLimitsValid = () => {
+    if (!limitStart || !limitEnd) return false;
+    if (!isValidDateFormatLimit(limitStart) || !isValidDateFormatLimit(limitEnd))
+      return false;
+    return true;
+  };
+  const limitedDates = React.useMemo(() => {
+    if (!checkLimitsValid()) return [];
+    const startDate = new Date(limitStart);
+    const endDate = new Date(limitEnd);
+    const datesArray = [];
+    for (let d = new Date(startDate); d <= endDate; d.setUTCDate(d.getUTCDate() + 1)) {
+      datesArray.push(new Date(d));
+    }
+    return datesArray;
+  }, [limitStart, limitEnd]);
+  const isLimitedDate = React.useCallback(
+    (date2) => {
+      if (limitedDates && !!limitedDates.length) {
+        return !limitedDates.some((limit) => limit.getTime() === date2.getTime());
+      }
+      return false;
+    },
+    [limitedDates]
+  );
+  const renderCalendarDate = (date2, index) => {
+    const { current, month, year } = dateState;
+    const _date = new Date(date2.join("-"));
+    const isLimited = isLimitedDate(_date);
+    const isToday = helpers_calendar.isSameDay(_date, /* @__PURE__ */ new Date());
+    const isCurrent = current && helpers_calendar.isSameDay(_date, current);
+    const inMonth = month && year && helpers_calendar.isSameMonth(
+      _date,
+      new Date(
+        [
+          year.toString().padStart(2, "0"),
+          month.toString().padStart(2, "0"),
+          "01"
+        ].join("-")
+      )
+    );
+    const DateComponent = isCurrent ? HighlightedCalendarDate : isToday ? TodayCalendarDate : CalendarDate;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      DateComponent,
+      {
+        $index: index,
+        $inMonth: inMonth,
+        $isLimited: isLimited,
+        onClick: (e) => {
+          if (isLimited) return;
+          gotoDate(_date, e);
+        },
+        children: _date.getDate()
+      },
+      helpers_calendar.getDateISO(_date)
+    );
+  };
+  const getCalendarYears = () => {
+    const years_render = helpers_calendar.CALENDAR_YEARS * 4;
+    const { year } = dateState;
+    const _years = [...new Array(years_render)].map((_, index) => {
+      return +year + index;
+    });
+    return _years;
+  };
+  const renderCalendarYears = (_year) => {
+    const { current, year } = dateState;
+    const isActive = _year === year;
+    const isCurrent = current && current.getFullYear() === _year;
+    const Component = isActive ? HighlightedCalendarNonDate : isCurrent ? CurrentCalendarNonDate : CalendarNonDate;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      Component,
+      {
+        onClick: (e) => gotoYear(_year, e),
+        children: _year
+      },
+      _year
+    );
+  };
+  const renderCalendarMonths = (_month, index) => {
+    const { current, year, month } = dateState;
+    const isActive = index + 1 === month;
+    const isSameYear = current && current.getFullYear() === year;
+    const isSameMonth2 = current && current.getMonth() + 1 === index + 1;
+    const isCurrent = isSameYear && isSameMonth2;
+    const Component = isActive ? HighlightedCalendarNonDate : isCurrent ? CurrentCalendarNonDate : CalendarNonDate;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      Component,
+      {
+        onClick: (e) => gotoMonth(index + 1, e),
+        children: _month.slice(0, 3)
+      },
+      _month
+    );
+  };
+  const handleHeaderEvent = (e) => {
+    e && e.preventDefault();
+    if (view === "date") {
+      return setView("year");
+    }
+    return;
+  };
+  const handlePrevious = () => {
+    const { month, year } = dateState;
+    if (view === "date") {
+      const previousMonth = helpers_calendar.getPreviousMonth(month, year);
+      setDateState({
+        month: previousMonth.month,
+        year: previousMonth.year,
+        current: dateState.current
+      });
+      return;
+    }
+    if (view === "year") {
+      const nextYears = year - helpers_calendar.CALENDAR_YEARS * 4;
+      setDateState({
+        month: dateState.month,
+        year: nextYears,
+        current: dateState.current
+      });
+      return;
+    }
+    if (view === "month") {
+      setDateState({
+        month: dateState.month,
+        current: dateState.current,
+        year: dateState.year - 1
+      });
+      return;
+    }
+  };
+  const handleNext = () => {
+    const { month, year } = dateState;
+    if (view === "date") {
+      const nextMonth = helpers_calendar.getNextMonth(month, year);
+      setDateState({
+        month: nextMonth.month,
+        year: nextMonth.year,
+        current: dateState.current
+      });
+      return;
+    }
+    if (view === "year") {
+      const nextYears = year + helpers_calendar.CALENDAR_YEARS * 4;
+      setDateState({
+        month: dateState.month,
+        year: nextYears,
+        current: dateState.current
+      });
+      return;
+    }
+    if (view === "month") {
+      setDateState({
+        month: dateState.month,
+        current: dateState.current,
+        year: dateState.year + 1
+      });
+      return;
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(CalendarContainer, { children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(CalendarHeader, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        IconButton.default,
+        {
+          onClick: handlePrevious,
+          title: "Previous Month",
+          icon: "go-left",
+          intent: "info",
+          variant: "secondaryOutlined",
+          shape: "rounded",
+          size: "small"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { children: /* @__PURE__ */ jsxRuntime.jsxs("button", { onClick: handleHeaderEvent, children: [
+        view === "date" && renderMonthAndYear.monthname + " " + renderMonthAndYear.year,
+        view === "year" && renderMonthAndYear.year + "-" + (renderMonthAndYear.year + helpers_calendar.CALENDAR_YEARS * 4 - 1),
+        view === "month" && renderMonthAndYear.year
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        IconButton.default,
+        {
+          onClick: handleNext,
+          title: "Next Month",
+          icon: "go-right",
+          intent: "info",
+          variant: "secondaryOutlined",
+          shape: "rounded",
+          size: "small"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(CalendarGrid, { $view: view, children: [
+      view === "date" && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: Object.keys(helpers_calendar.WEEK_DAYS).map(renderDayLabel) }),
+        /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: getCalendarDates().map(renderCalendarDate) })
+      ] }),
+      view === "year" && /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: getCalendarYears().map(renderCalendarYears) }),
+      view === "month" && /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: Object.values(helpers_calendar.CALENDAR_MONTHS).map(renderCalendarMonths) })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(CalendarFooter, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        Button.default,
+        {
+          onClick: () => {
+            checkLimitsValid() ? addDateToState(new Date(limitStart)) : addDateToState(/* @__PURE__ */ new Date());
+            onDateChanged && (checkLimitsValid() ? onDateChanged(new Date(limitStart)) : onDateChanged(/* @__PURE__ */ new Date()));
+            setCalendarOpen && setCalendarOpen(false);
+          },
+          width: "auto",
+          intent: "accent",
+          variant: "secondaryOutlined",
+          label: "Reseteaza"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        Button.default,
+        {
+          onClick: () => {
+            setCalendarOpen && setCalendarOpen(false);
+          },
+          width: "auto",
+          intent: "accent",
+          variant: "primary",
+          label: "Salveaza"
+        }
+      )
+    ] })
+  ] });
+};
+
+exports.default = Calendar;

package/build/cjs/components/Datepicker/Datepicker.cjs

@@ -0,0 +1,206 @@
+"use strict";
+"use client";
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var styled = require('styled-components');
+var Icon = require('../Icon/Icon.cjs');
+var utils = require('../../utils');
+var Calendar = require('./Calendar.cjs');
+var helpers_calendar = require('./helpers_calendar.cjs');
+
+const sizesDatePickerVariants = {
+  medium: styled.css`
+    height: 40px;
+    padding: 0px 38px 0px 12px;
+  `,
+  large: styled.css`
+    height: 48px;
+    padding: 0px 42px 0px 16px;
+  `
+};
+const CalendarWrapperStyled = styled.div`
+  position: absolute;
+  left: 0;
+  z-index: 300;
+
+  ${({ $position }) => $position === "top" ? styled.css`
+          bottom: 100%;
+          margin-bottom: 10px;
+        ` : styled.css`
+          top: 100%;
+          margin-top: 10px;
+        `}
+`;
+const DatePickerStyled = styled.div`
+  position: relative;
+  width: 100%;
+
+  & > div:first-of-type {
+    position: absolute;
+    top: 0;
+    right: 10px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    pointer-events: none;
+  }
+
+  & > input {
+    outline: none;
+    appearance: none;
+    border: none;
+    cursor: pointer;
+    width: 100%;
+    box-sizing: border-box;
+    border-radius: 8px;
+    background-color: ${(props) => props.$disabled ? utils.colors.gray_30 : utils.colors.gray_100};
+    color: ${(props) => props.$disabled ? utils.colors.gray_500 : utils.colors.gray_950};
+    font-weight: 400;
+    font-family: Amalia, sans-serif;
+    font-size: ${(props) => props.$size && typeof props.$size === "string" && (props.$size === "large" ? "16px" : "14px")};
+
+    ${({ $intent }) => $intent === "danger" && styled.css`
+        outline: 2px solid ${utils.colors.danger_500};
+      `}
+
+    ${({ $calendarOpen }) => $calendarOpen && styled.css`
+        outline: 2px solid ${utils.colors.accent_600};
+      `}
+
+    ${(props) => props.$size && typeof props.$size === "string" && sizesDatePickerVariants[props.$size]};
+
+    &::placeholder {
+      color: ${(props) => props.$disabled ? utils.colors.gray_500 : utils.colors.gray_600};
+    }
+
+    ${({ $disabled }) => $disabled && styled.css`
+        background-color: ${utils.colors.gray_30};
+      `}
+  }
+`;
+const Datepicker = ({
+  id,
+  name,
+  placeholder,
+  type = "date",
+  value,
+  setValue,
+  size = "medium",
+  intent = "default",
+  disabled,
+  limitStart = "",
+  limitEnd = "",
+  defaultOpen = false,
+  ...rest
+}) => {
+  const [calendarOpen, setCalendarOpen] = React.useState(defaultOpen);
+  const [position, setPosition] = React.useState("bottom");
+  const wrapper_reference = React.useRef(null);
+  const handleDateChange = (date) => {
+    setValue(date);
+  };
+  React.useEffect(() => {
+    console.log({ defaultOpen });
+    setCalendarOpen(defaultOpen);
+  }, [defaultOpen]);
+  React.useEffect(() => {
+    const handleOutside = (e) => {
+      if (wrapper_reference.current && !wrapper_reference.current.contains(e.target)) {
+        setCalendarOpen(false);
+      }
+    };
+    if (calendarOpen) {
+      document.addEventListener("mousedown", handleOutside);
+      return () => {
+        document.removeEventListener("mousedown", handleOutside);
+      };
+    }
+  }, [calendarOpen, wrapper_reference]);
+  const formatted = React.useMemo(() => {
+    if (!value) return "";
+    if (type === "date") return value?.toString();
+    if (type === "type1") {
+      return new Intl.DateTimeFormat("ro-RO", {
+        year: "numeric",
+        month: "long",
+        day: "numeric"
+      }).format(value);
+    }
+    if (type === "type2") {
+      return new Intl.DateTimeFormat("ro-RO", {
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit"
+      }).format(value).replace(/\./g, "/");
+    }
+  }, [value, type]);
+  React.useEffect(() => {
+    const handleDynamicPosition = () => {
+      if (wrapper_reference.current) {
+        const { y } = wrapper_reference.current.getBoundingClientRect();
+        if (y < 465) {
+          setPosition("bottom");
+        } else {
+          setPosition("top");
+        }
+      }
+    };
+    window.addEventListener("scroll", handleDynamicPosition);
+    return () => {
+      window.removeEventListener("scroll", handleDynamicPosition);
+    };
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    DatePickerStyled,
+    {
+      ref: wrapper_reference,
+      $size: size,
+      $intent: intent,
+      $disabled: disabled,
+      $calendarOpen: calendarOpen,
+      ...rest,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            id,
+            name,
+            type: "text",
+            readOnly: true,
+            onChange: (e) => e.preventDefault(),
+            onClick: () => !disabled && setCalendarOpen(true),
+            value: formatted,
+            disabled,
+            placeholder
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { children: /* @__PURE__ */ jsxRuntime.jsx(
+          Icon.default,
+          {
+            icon: "calendar",
+            size: 20,
+            color: disabled ? utils.colors.info_500_40 : utils.colors.info_700
+          }
+        ) }),
+        calendarOpen && /* @__PURE__ */ jsxRuntime.jsx(CalendarWrapperStyled, { $position: position, children: /* @__PURE__ */ jsxRuntime.jsx(
+          Calendar.default,
+          {
+            limitStart,
+            limitEnd,
+            date: helpers_calendar.isDate(value) ? value : /* @__PURE__ */ new Date(),
+            onDateChanged: handleDateChange,
+            setCalendarOpen
+          }
+        ) })
+      ]
+    }
+  );
+};
+
+exports.default = Datepicker;