@trilogy-ds/react 0.0.16-esm-cjs → 0.0.18-esm-cjs

package/lib/chunk-Y6VHQF2J.mjs

@@ -0,0 +1,548 @@
+"use client";
+import {
+  useClickOutside
+} from "./chunk-GCIF33S4.mjs";
+import {
+  ModalBody_default
+} from "./chunk-ABTLCSFA.mjs";
+import {
+  Modal_default
+} from "./chunk-CYSI752N.mjs";
+import {
+  Calendar_default
+} from "./chunk-JB7AXJFO.mjs";
+import {
+  Icon_default
+} from "./chunk-ALGX47MZ.mjs";
+import {
+  Text_default
+} from "./chunk-HHE7L3CW.mjs";
+import {
+  has,
+  is
+} from "./chunk-SWVRRUW7.mjs";
+import {
+  hashClass
+} from "./chunk-UFMRE754.mjs";
+import {
+  useTrilogyContext
+} from "./chunk-ZB4OWTDD.mjs";
+
+// components/datepicker/DatePicker.tsx
+import clsx from "clsx";
+import React, {
+  forwardRef,
+  useCallback,
+  useEffect,
+  useImperativeHandle,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import ReactDOM from "react-dom";
+var APPROXIMATIVE_HEIGHT_CALENDAR = 420;
+var checkIsValidDate = (date, year, month, day) => date.getFullYear() === parseInt(year) && date.getMonth() === parseInt(month) - 1 && date.getDate() === parseInt(day) && !isNaN(date.getTime());
+var getFirstDayFocusable = () => {
+  var _a;
+  const calendar = document.querySelector("[data-calendar-trilogy]");
+  const activeDate = calendar.querySelector(`[data-active-date]`);
+  const today = calendar.querySelector(`[data-today]`);
+  const firstOfMonth = calendar.querySelector(`[data-calendar-trilogy] tbody button:not(:disabled)`);
+  return (_a = activeDate != null ? activeDate : today) != null ? _a : firstOfMonth;
+};
+var DatePicker = forwardRef(
+  ({
+    onChange,
+    value,
+    minDate,
+    maxDate,
+    className,
+    label,
+    sample,
+    required,
+    help,
+    status,
+    disabled,
+    disabledDates,
+    id = React.useId(),
+    testId,
+    name,
+    ...others
+  }, ref) => {
+    const { styled } = useTrilogyContext();
+    const { "data-cy": dataCy, ...otherProps } = others;
+    const [day, setDay] = useState("jj");
+    const [month, setMonth] = useState("mm");
+    const [year, setYear] = useState("aaaa");
+    const [isOpenCalendar, setIsOpenCalendar] = useState(false);
+    const [canContinueTyping, setCanContinueTyping] = useState(false);
+    const [focused, setIsFocused] = useState(false);
+    const [isMobile, setIsMobile] = useState(false);
+    const [portalPosition, setPortalPosition] = useState({ top: 0, left: 0, width: 0 });
+    const refsSegment = useRef([]);
+    const refsFocusable = useRef([]);
+    const refContainer = useRef(null);
+    const refCalendar = useRef(null);
+    const currentFocusIndexRef = useRef(0);
+    const segmentFocused = useRef(null);
+    const refIcon = useRef(null);
+    const refInput = useRef(null);
+    const calendarContainerClasses = hashClass(styled, clsx("date-picker-calendar"));
+    const datePickerClasses = hashClass(styled, clsx("field date-picker", className));
+    const controlClasses = hashClass(styled, clsx("control", has("icons-right")));
+    const inputClasses = hashClass(styled, clsx("input", status && is(status), focused && is("focused")));
+    const iconRightClasses = hashClass(styled, clsx("icon-right"));
+    const helpClasses = clsx("help", status && is(status));
+    const inputLabelClasses = hashClass(styled, "input-label");
+    const inputHidden = hashClass(styled, "input-hidden");
+    useImperativeHandle(ref, () => refContainer.current);
+    useClickOutside(refCalendar, () => {
+      setTimeout(() => {
+        setIsOpenCalendar(false);
+      }, 0);
+    });
+    useClickOutside(refInput, () => {
+      setTimeout(() => {
+        setIsFocused(false);
+      }, 0);
+    });
+    const segments = useMemo(
+      () => ({
+        day: {
+          sensitiveValue: 3,
+          maxValue: 31,
+          segment: day,
+          segmentPosition: 0,
+          segmentSetter: setDay,
+          label: "jj",
+          initValue: "01"
+        },
+        month: {
+          sensitiveValue: 1,
+          maxValue: 12,
+          segment: month,
+          segmentPosition: 1,
+          segmentSetter: setMonth,
+          label: "mm",
+          initValue: "01"
+        },
+        year: {
+          sensitiveValue: false,
+          maxValue: 9999,
+          segment: year,
+          segmentPosition: 2,
+          segmentSetter: setYear,
+          label: "aaaa",
+          initValue: String((/* @__PURE__ */ new Date()).getFullYear())
+        }
+      }),
+      [day, month, year]
+    );
+    const calendarValue = useMemo(() => {
+      if (parseInt(day) && parseInt(month) && parseInt(year)) {
+        const newDate = /* @__PURE__ */ new Date(`${year}-${month}-${day}`);
+        const isValidDate = checkIsValidDate(newDate, year, month, day);
+        if (isValidDate) return newDate;
+      }
+    }, [day, month, year]);
+    const calculatePortalPosition = useCallback(() => {
+      if (!refInput.current) return;
+      const rect = refInput.current.getBoundingClientRect();
+      const { top, bottom, left, width } = rect;
+      const windowHeight = window.innerHeight;
+      const spaceBelow = windowHeight - bottom;
+      const padding = 10;
+      const maxHeightBelow = spaceBelow - padding;
+      const maxHeightAbove = top - padding;
+      const shouldOpenUpward = maxHeightBelow < APPROXIMATIVE_HEIGHT_CALENDAR && maxHeightAbove > maxHeightBelow;
+      const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+      const scrollLeft = window.pageXOffset || document.documentElement.scrollLeft;
+      setPortalPosition({
+        top: shouldOpenUpward ? top + scrollTop - APPROXIMATIVE_HEIGHT_CALENDAR - padding : bottom + scrollTop + padding,
+        left: left + scrollLeft,
+        width
+      });
+    }, []);
+    const handleKeyPress = useCallback(
+      ({ event, type }) => {
+        if (disabled) return;
+        const key = event.data;
+        event.preventDefault();
+        const allowedKeys = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
+        if (!allowedKeys.includes(key)) return;
+        const digit = parseInt(key);
+        const { segmentPosition, segment, segmentSetter, sensitiveValue, maxValue } = segments[type];
+        const isDay = type === "day";
+        const isMonth = type === "month";
+        const isYear = type === "year";
+        const newValue = !canContinueTyping ? isYear ? `000${key}` : `0${key}` : isYear ? segment + key : segment[1] + key;
+        if (!canContinueTyping) {
+          segmentSetter(newValue);
+          if (sensitiveValue === false || digit <= sensitiveValue) setCanContinueTyping(true);
+          if (sensitiveValue && digit > sensitiveValue)
+            setTimeout(() => {
+              if (segmentPosition < 2) refsSegment.current[segmentPosition + 1].focus();
+            }, 0);
+        }
+        if (canContinueTyping) {
+          const num = parseInt(newValue);
+          if (isYear && String(num).length === 5) return;
+          if (num >= 1 && num <= maxValue) segmentSetter(isYear ? newValue.slice(-4) : newValue);
+          if (!isYear) {
+            setCanContinueTyping(false);
+            setTimeout(() => {
+              if (segmentPosition < 2) refsSegment.current[segmentPosition + 1].focus();
+            }, 0);
+          }
+        }
+        const newDay = isDay ? newValue : day;
+        const newMonth = isMonth ? newValue : month;
+        const newYear = isYear ? newValue : year;
+        if (parseInt(newDay) && parseInt(newMonth) && parseInt(newYear)) {
+          if (onChange) onChange(`${newYear.slice(-4)}-${newMonth}-${newDay}`);
+        }
+      },
+      [disabled, segments, canContinueTyping, onChange]
+    );
+    const formatDateValue = () => {
+      const isValidDate = parseInt(day) && parseInt(month) && parseInt(year);
+      return !isValidDate ? "" : `${year}-${month}-${day}`;
+    };
+    const handleKeyDownDay = useCallback(
+      (e, type) => {
+        if (disabled) return;
+        const { segmentSetter, label: label2, maxValue, initValue, segmentPosition, segment } = segments[type];
+        switch (e.key) {
+          case "Backspace":
+            e.preventDefault();
+            setCanContinueTyping(false);
+            segmentSetter(label2);
+            break;
+          case " ":
+            e.preventDefault();
+            setIsOpenCalendar(true);
+            segmentFocused.current = refsSegment.current[segmentPosition];
+            break;
+          case "Escape":
+            e.preventDefault();
+            setIsOpenCalendar(false);
+            break;
+          case "ArrowUp":
+            e.preventDefault();
+            const currentValue = parseInt(segment) || 0;
+            const nextValue = currentValue % maxValue + 1;
+            const availableValue = type === "year" && segment === "aaaa" ? initValue : String(nextValue).padStart(2, "0");
+            segmentSetter(availableValue);
+            const updatedDayUp = type === "day" ? availableValue : day;
+            const updatedMonthUp = type === "month" ? availableValue : month;
+            const updatedYearUp = type === "year" ? availableValue : year;
+            if (parseInt(updatedDayUp) && parseInt(updatedMonthUp) && parseInt(updatedYearUp) && onChange) {
+              onChange(`${updatedYearUp}-${updatedMonthUp}-${updatedDayUp}`);
+            }
+            break;
+          case "ArrowDown":
+            e.preventDefault();
+            const value2 = parseInt(segment) || maxValue;
+            const nextVal = value2 <= 1 ? maxValue : value2 - 1;
+            const availableVal = type === "year" && segment === "aaaa" ? initValue : String(nextVal).padStart(2, "0");
+            segmentSetter(availableVal);
+            const updatedDayDown = type === "day" ? availableVal : day;
+            const updatedMonthDown = type === "month" ? availableVal : month;
+            const updatedYearDown = type === "year" ? availableVal : year;
+            if (parseInt(updatedDayDown) && parseInt(updatedMonthDown) && parseInt(updatedYearDown) && onChange) {
+              onChange(`${updatedYearDown}-${updatedMonthDown}-${updatedDayDown}`);
+            }
+            break;
+          default:
+            return;
+        }
+      },
+      [disabled, segments, year, month, day]
+    );
+    const handleFocus = () => {
+      if (disabled) return;
+      setIsFocused(true);
+      setCanContinueTyping(false);
+    };
+    const handlePressCalendar = () => {
+      if (disabled) return;
+      if (refContainer.current) segmentFocused.current = refIcon.current;
+      calculatePortalPosition();
+      setIsOpenCalendar(true);
+    };
+    const handleChangeCalendar = React.useCallback(
+      (e) => {
+        const dateCalendar = e;
+        const dateDay = dateCalendar.getDate();
+        const dateMonth = dateCalendar.getMonth() + 1;
+        const dateYear = dateCalendar.getFullYear();
+        const dayFormated = dateDay < 10 ? `0${dateDay}` : String(dateDay);
+        const monthFormated = dateMonth < 10 ? `0${dateMonth}` : String(dateMonth);
+        const yearFormated = String(dateYear);
+        setDay(dayFormated);
+        setMonth(monthFormated);
+        setYear(yearFormated);
+        setIsOpenCalendar(false);
+        if (onChange) onChange(`${yearFormated}-${monthFormated}-${dayFormated}`);
+      },
+      [onChange]
+    );
+    const onKeyDown = useCallback(
+      (e) => {
+        var _a;
+        if (disabled) return;
+        if (isOpenCalendar && e.key === "Tab") {
+          e.preventDefault();
+          if (refsFocusable.current) {
+            const currentIndex = currentFocusIndexRef.current;
+            const offset = e.shiftKey ? -1 : 1;
+            const nextIndex = (currentIndex + offset + (refsFocusable == null ? void 0 : refsFocusable.current.length)) % (refsFocusable == null ? void 0 : refsFocusable.current.length);
+            currentFocusIndexRef.current = nextIndex;
+            refsFocusable.current[nextIndex].focus();
+          }
+        }
+        if (isOpenCalendar && ["Escape", "Enter"].includes(e.key)) {
+          e.preventDefault();
+          setIsOpenCalendar(false);
+          (_a = segmentFocused.current) == null ? void 0 : _a.focus();
+        }
+      },
+      [disabled, isOpenCalendar]
+    );
+    const calendar = useMemo(() => {
+      return /* @__PURE__ */ React.createElement(
+        Calendar_default,
+        {
+          disabledDates,
+          maxDate: maxDate ? new Date(maxDate) : void 0,
+          minDate: minDate ? new Date(minDate) : void 0,
+          onChange: handleChangeCalendar,
+          ref: refCalendar,
+          value: calendarValue,
+          onMonthChange: () => {
+            if (isOpenCalendar && refCalendar.current) {
+              const calendar2 = refCalendar.current;
+              setTimeout(() => {
+                refsFocusable.current = [];
+                const elms = calendar2.querySelectorAll(`[data-focusable=true]`);
+                const firstDayFocusable = getFirstDayFocusable();
+                refsFocusable.current[0] = firstDayFocusable;
+                elms.forEach((el, i) => {
+                  const htmlElement = el;
+                  if (htmlElement) refsFocusable.current[i + 1] = htmlElement;
+                });
+              }, 10);
+            }
+          }
+        }
+      );
+    }, [
+      disabledDates,
+      maxDate,
+      minDate,
+      handleChangeCalendar,
+      refCalendar,
+      calendarValue,
+      isOpenCalendar,
+      refsFocusable
+    ]);
+    useEffect(() => {
+      if (!value) {
+        setDay("jj");
+        setMonth("mm");
+        setYear("aaaa");
+      } else {
+        const [year2, month2, day2] = value.split("-");
+        setDay(day2);
+        setMonth(month2);
+        setYear(year2);
+      }
+    }, [value]);
+    useEffect(() => {
+      if (isOpenCalendar && refCalendar.current) {
+        const elms = refCalendar.current.querySelectorAll(`[data-focusable=true]`);
+        const firstDayFocusable = getFirstDayFocusable();
+        refsFocusable.current[0] = firstDayFocusable;
+        firstDayFocusable.focus();
+        elms.forEach((el, i) => {
+          const htmlElement = el;
+          if (htmlElement) refsFocusable.current[i + 1] = htmlElement;
+        });
+      }
+      if (!isOpenCalendar && currentFocusIndexRef.current) currentFocusIndexRef.current = 0;
+    }, [isOpenCalendar, refCalendar, currentFocusIndexRef]);
+    useEffect(() => {
+      const handleResize = () => setIsMobile(window.innerWidth <= 768);
+      handleResize();
+      window.addEventListener("resize", handleResize);
+      return () => window.removeEventListener("resize", handleResize);
+    }, []);
+    useEffect(() => {
+      if (!isOpenCalendar) return;
+      const handleUpdate = () => calculatePortalPosition();
+      window.addEventListener("scroll", handleUpdate, true);
+      window.addEventListener("resize", handleUpdate);
+      return () => {
+        window.removeEventListener("scroll", handleUpdate, true);
+        window.removeEventListener("resize", handleUpdate);
+      };
+    }, [isOpenCalendar, calculatePortalPosition]);
+    return /* @__PURE__ */ React.createElement("div", { ref: refContainer, className: datePickerClasses, onKeyDown }, label && /* @__PURE__ */ React.createElement("label", { className: inputLabelClasses, htmlFor: id }, label, " ", required && /* @__PURE__ */ React.createElement(Text_default, { markup: "span" /* SPAN */, typo: "has-text-error" /* TEXT_ERROR */ }, "*")), sample && /* @__PURE__ */ React.createElement(Text_default, { className: "input-sample", level: 2 /* TWO */ }, sample), /* @__PURE__ */ React.createElement("div", { className: controlClasses }, /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        role: "group",
+        "aria-valuetext": formatDateValue(),
+        "aria-disabled": disabled,
+        ref: refInput,
+        className: inputClasses,
+        onMouseDown: (e) => {
+          if (disabled) return;
+          const clickedSegment = refsSegment.current.find((segment) => segment === document.activeElement);
+          if (clickedSegment) return e.preventDefault();
+          setTimeout(() => {
+            refsSegment.current[0].focus();
+          }, 0);
+        },
+        ...otherProps
+      },
+      /* @__PURE__ */ React.createElement(
+        "span",
+        {
+          "aria-valuemin": 1,
+          "aria-valuemax": 31,
+          "aria-readonly": false,
+          "aria-label": "day",
+          role: "spinbutton",
+          suppressContentEditableWarning: true,
+          autoCorrect: "off",
+          autoCapitalize: "none",
+          spellCheck: false,
+          "aria-valuetext": day,
+          contentEditable: !disabled,
+          inputMode: "numeric",
+          onBeforeInput: (e) => handleKeyPress({ event: e, type: "day" }),
+          onFocus: handleFocus,
+          onKeyDown: (e) => handleKeyDownDay(e, "day"),
+          onMouseDown: (e) => e.stopPropagation(),
+          onChange: (e) => e.stopPropagation(),
+          onInput: () => refsSegment.current[0].textContent = day,
+          ref: (el) => {
+            if (el) refsSegment.current[0] = el;
+          }
+        },
+        day
+      ),
+      /* @__PURE__ */ React.createElement("span", null, "/"),
+      /* @__PURE__ */ React.createElement(
+        "span",
+        {
+          "aria-valuemin": 1,
+          "aria-valuemax": 12,
+          "aria-readonly": false,
+          "aria-label": "month",
+          role: "spinbutton",
+          suppressContentEditableWarning: true,
+          autoCorrect: "off",
+          autoCapitalize: "none",
+          spellCheck: false,
+          "aria-valuetext": month,
+          contentEditable: !disabled,
+          inputMode: "numeric",
+          onBeforeInput: (e) => handleKeyPress({ event: e, type: "month" }),
+          onFocus: handleFocus,
+          onKeyDown: (e) => handleKeyDownDay(e, "month"),
+          onMouseDown: (e) => e.stopPropagation(),
+          onChange: (e) => e.stopPropagation(),
+          onInput: () => refsSegment.current[1].textContent = month,
+          ref: (el) => {
+            if (el) refsSegment.current[1] = el;
+          }
+        },
+        month
+      ),
+      /* @__PURE__ */ React.createElement("span", null, "/"),
+      /* @__PURE__ */ React.createElement(
+        "span",
+        {
+          "aria-valuemin": 0,
+          "aria-valuemax": 9999,
+          "aria-readonly": false,
+          "aria-label": "year",
+          role: "spinbutton",
+          suppressContentEditableWarning: true,
+          autoCorrect: "off",
+          autoCapitalize: "none",
+          spellCheck: false,
+          "aria-valuetext": year,
+          contentEditable: !disabled,
+          inputMode: "numeric",
+          onBeforeInput: (e) => handleKeyPress({ event: e, type: "year" }),
+          onFocus: handleFocus,
+          onKeyDown: (e) => handleKeyDownDay(e, "year"),
+          onMouseDown: (e) => e.stopPropagation(),
+          onChange: (e) => e.stopPropagation(),
+          onInput: () => refsSegment.current[2].textContent = year,
+          ref: (el) => {
+            if (el) refsSegment.current[2] = el;
+          }
+        },
+        year
+      ),
+      /* @__PURE__ */ React.createElement(
+        "input",
+        {
+          disabled,
+          name,
+          type: "text",
+          id,
+          "data-testid": testId,
+          value: `${year}-${month}-${day}`,
+          "data-cy": dataCy,
+          tabIndex: -1,
+          className: inputHidden,
+          onChange: (e) => {
+            const [year2, month2, day2] = e.target.value.split("-");
+            setDay(day2);
+            setMonth(month2);
+            setYear(year2);
+          }
+        }
+      )
+    ), /* @__PURE__ */ React.createElement(
+      "button",
+      {
+        type: "button",
+        tabIndex: disabled ? -1 : void 0,
+        onClick: handlePressCalendar,
+        ref: refIcon,
+        "data-show-calendar": "true",
+        onFocus: () => {
+          setIsFocused(false);
+        }
+      },
+      /* @__PURE__ */ React.createElement(Icon_default, { name: "tri-calendar", className: iconRightClasses })
+    )), help && /* @__PURE__ */ React.createElement(Text_default, { className: helpClasses }, help), isOpenCalendar && !isMobile && ReactDOM.createPortal(
+      /* @__PURE__ */ React.createElement(
+        "div",
+        {
+          className: calendarContainerClasses,
+          style: {
+            position: "absolute",
+            top: `${portalPosition.top}px`,
+            left: `${portalPosition.left}px`,
+            minWidth: `${portalPosition.width}px`,
+            zIndex: 9999
+          }
+        },
+        calendar
+      ),
+      document.body
+    ), isOpenCalendar && isMobile && /* @__PURE__ */ React.createElement(Modal_default, { active: isOpenCalendar, hideCloseButton: true }, /* @__PURE__ */ React.createElement(ModalBody_default, null, calendar)));
+  }
+);
+DatePicker.displayName = "DatePicker" /* DatePicker */;
+var DatePicker_default = DatePicker;
+
+export {
+  DatePicker_default
+};

package/lib/{chunk-R7ZJGYVD.mjs → chunk-Y7WPI233.mjs}

@@ -1,10 +1,10 @@
 "use client";
 import {
   getBackgroundClassName
-} from "./chunk-WC3ULY5W.mjs";
+} from "./chunk-XXKEMYTB.mjs";
 import {
   getColorClassName
-} from "./chunk-JOSZ4COK.mjs";
+} from "./chunk-7VSJ3RTI.mjs";
 import {
   has,
   is

package/lib/chunk-Y7YLMIQH.mjs

@@ -0,0 +1 @@
+"use client";

package/lib/{chunk-VWBRZW2B.mjs → chunk-YF74SWNR.mjs}

@@ -1,13 +1,13 @@
 "use client";
 import {
   Title_default
-} from "./chunk-TB5FNQJR.mjs";
+} from "./chunk-M3FKAS2D.mjs";
 import {
   Text_default
 } from "./chunk-HHE7L3CW.mjs";
 import {
   getColorStyle
-} from "./chunk-JOSZ4COK.mjs";
+} from "./chunk-7VSJ3RTI.mjs";
 import {
   is
 } from "./chunk-SWVRRUW7.mjs";

package/lib/{chunk-MKOK7VNZ.mjs → chunk-YKUYXBXK.mjs}

@@ -1,7 +1,7 @@
 "use client";
 import {
   getColorStyle
-} from "./chunk-VI2KFLCZ.mjs";
+} from "./chunk-E4YRRUI3.mjs";
 
 // objects/facets/Variant/index.native.ts
 var VariantState = /* @__PURE__ */ ((VariantState2) => {

package/lib/{chunk-TTMI7WFG.mjs → chunk-YR5WZRJD.mjs}

@@ -1,7 +1,7 @@
 "use client";
 import {
   TabPanel_default
-} from "./chunk-TBFT5WCF.mjs";
+} from "./chunk-BD73QGIH.mjs";
 
 // components/tabs/tab-panels/tab-panel/index.ts
 var tab_panel_default = TabPanel_default;

package/lib/{chunk-LQ7MOJFV.mjs → chunk-YSBY3XJC.mjs}

@@ -1,21 +1,21 @@
 "use client";
 import {
   View_native_default
-} from "./chunk-MK63OCEA.mjs";
+} from "./chunk-4GKCUICZ.mjs";
 import {
   Text_native_default
-} from "./chunk-2AL4D3MJ.mjs";
+} from "./chunk-MVQ252OA.mjs";
 
 // components/list/item/description/ListItemDescription.native.tsx
 import * as React from "react";
-var ListItemDescription = React.forwardRef(
-  ({ children }, ref) => {
-    if (["string", "number"].includes(typeof children)) {
-      return /* @__PURE__ */ React.createElement(Text_native_default, null, children);
-    }
-    return /* @__PURE__ */ React.createElement(View_native_default, { ref }, children);
+var ListItemDescription = React.forwardRef(({
+  children
+}, ref) => {
+  if (["string", "number"].includes(typeof children)) {
+    return /* @__PURE__ */ React.createElement(Text_native_default, null, children);
   }
-);
+  return /* @__PURE__ */ React.createElement(View_native_default, { ref }, children);
+});
 ListItemDescription.displayName = "ListItemDescription" /* ListItemDescription */;
 var ListItemDescription_native_default = ListItemDescription;
 

package/lib/{chunk-EQIF6RE5.mjs → chunk-ZEEM3OU3.mjs}

@@ -7,29 +7,29 @@ import {
 } from "./chunk-3WFGK5PF.mjs";
 import {
   Title_native_default
-} from "./chunk-AK2SCURT.mjs";
+} from "./chunk-MDZE2AV3.mjs";
 import {
   Column_native_default
-} from "./chunk-UV7KNMPY.mjs";
+} from "./chunk-ZNF2AXYR.mjs";
 import {
   Columns_native_default
-} from "./chunk-5RU72DNI.mjs";
+} from "./chunk-NRTMJLXK.mjs";
 import {
   View_native_default
-} from "./chunk-MK63OCEA.mjs";
+} from "./chunk-4GKCUICZ.mjs";
 import {
   Text_native_default
-} from "./chunk-2AL4D3MJ.mjs";
+} from "./chunk-MVQ252OA.mjs";
 import {
   Spacer_native_default
 } from "./chunk-54DJB6AO.mjs";
 import {
   getStatusIconName,
   getStatusStyle
-} from "./chunk-KNRXLZZP.mjs";
+} from "./chunk-MB55ARZ7.mjs";
 import {
   Icon_native_default
-} from "./chunk-H6FVJB5Z.mjs";
+} from "./chunk-UPP3GX33.mjs";
 import {
   context_default
 } from "./chunk-YKBYBMP2.mjs";
@@ -79,7 +79,7 @@ var Alert = React.forwardRef(
       }
     });
     alertView = // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    /* @__PURE__ */ React.createElement(View_native_default, { style: [styles.container, others.style], ref }, /* @__PURE__ */ React.createElement(Columns_native_default, { gap: 2, verticalAlign: "ALIGNED_START" /* ALIGNED_START */ }, /* @__PURE__ */ React.createElement(Column_native_default, { narrow: true }, /* @__PURE__ */ React.createElement(View_native_default, { style: { marginTop: -2 } }, /* @__PURE__ */ React.createElement(Icon_native_default, { name: iconName ? iconName : getStatusIconName(status), color: status || "MAIN" /* MAIN */ }))), /* @__PURE__ */ React.createElement(Column_native_default, null, /* @__PURE__ */ React.createElement(Rows_native_default, { gap: description ? 2 : 0 }, /* @__PURE__ */ React.createElement(index_native_default, null, /* @__PURE__ */ React.createElement(Text_native_default, { style: [styles.containerTitle], level: 1 /* ONE */, typo: "has-text-weight-semibold" /* TEXT_WEIGHT_SEMIBOLD */ }, title)), /* @__PURE__ */ React.createElement(index_native_default, null, description && typeof description.valueOf() === "string" ? /* @__PURE__ */ React.createElement(Text_native_default, { level: 2 /* TWO */, style: styles.description }, description) : /* @__PURE__ */ React.createElement(View_native_default, { style: styles.description }, description))))));
+    /* @__PURE__ */ React.createElement(View_native_default, { style: [styles.container, others.style], ref }, /* @__PURE__ */ React.createElement(Columns_native_default, { gap: 2, verticalAlign: "ALIGNED_START" /* ALIGNED_START */ }, /* @__PURE__ */ React.createElement(Column_native_default, { narrow: true }, /* @__PURE__ */ React.createElement(View_native_default, { style: { marginTop: -2 } }, /* @__PURE__ */ React.createElement(Icon_native_default, { name: iconName ? iconName : getStatusIconName(status), color: status || "MAIN" /* MAIN */ }))), /* @__PURE__ */ React.createElement(Column_native_default, null, /* @__PURE__ */ React.createElement(Rows_native_default, { ...{ style: { flexGrow: 1 } }, gap: description ? 2 : 0 }, /* @__PURE__ */ React.createElement(index_native_default, null, /* @__PURE__ */ React.createElement(Text_native_default, { style: [styles.containerTitle], level: 1 /* ONE */, typo: "has-text-weight-semibold" /* TEXT_WEIGHT_SEMIBOLD */ }, title)), description && /* @__PURE__ */ React.createElement(Spacer_native_default, { size: 4 /* ONE */ }), /* @__PURE__ */ React.createElement(index_native_default, null, description && typeof description.valueOf() === "string" ? /* @__PURE__ */ React.createElement(Text_native_default, { level: 2 /* TWO */, style: styles.description }, description) : /* @__PURE__ */ React.createElement(View_native_default, { style: styles.description }, description))))));
     if (onClick && display)
       return /* @__PURE__ */ React.createElement(View_native_default, null, /* @__PURE__ */ React.createElement(TouchableOpacity, { onPress: onClick, activeOpacity: 0.85 }, alertView));
     if (!onClick && display) return alertView;