@synerise/ds-factors 1.11.11 → 1.11.13

package/dist/FactorValue/Parameter/useGroups.js

@@ -1,64 +1,52 @@
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-import { useMemo } from 'react';
-var itemIsParameterGroup = function itemIsParameterGroup(item) {
+import { useMemo } from "react";
+const itemIsParameterGroup = (item) => {
   return Boolean(item);
 };
-export var useGroups = function useGroups(items, groups, renderEmptyGroups) {
-  var defaultTab = useMemo(function () {
-    var defaultIndex = groups == null ? void 0 : groups.findIndex(function (group) {
-      return group.defaultGroup;
-    });
+const useGroups = (items, groups, renderEmptyGroups) => {
+  const defaultTab = useMemo(() => {
+    const defaultIndex = groups?.findIndex((group) => group.defaultGroup);
     return defaultIndex || 0;
   }, [groups]);
-  var visibleGroups = useMemo(function () {
+  const visibleGroups = useMemo(() => {
     if (renderEmptyGroups) {
       return groups;
     }
-    var groupIds = groups == null ? void 0 : groups.map(function (group) {
-      return group.subGroups || group;
-    }).flat().filter(function (group, index) {
-      return !(group.allowEmpty || index === 0);
-    }).map(function (group) {
-      return group.id;
-    });
-    var groupsToSkip = groupIds == null ? void 0 : groupIds.filter(function (groupId) {
-      return !(items != null && items.find(function (item) {
-        return item.groupId === groupId;
-      }));
-    });
-    var cleanGroups = groups == null ? void 0 : groups.map(function (group) {
+    const groupIds = groups?.map((group) => group.subGroups || group).flat().filter((group, index) => !(group.allowEmpty || index === 0)).map((group) => group.id);
+    const groupsToSkip = groupIds?.filter((groupId) => !items?.find((item) => item.groupId === groupId));
+    const cleanGroups = groups?.map((group) => {
       if (group.subGroups && group.subGroups.length) {
-        var filteredSubGroups = group.subGroups.filter(function (subGroup) {
-          return !(groupsToSkip != null && groupsToSkip.includes(subGroup.id));
-        });
+        const filteredSubGroups = group.subGroups.filter((subGroup) => !groupsToSkip?.includes(subGroup.id));
         switch (filteredSubGroups.length) {
           case 0:
-            return undefined;
+            return void 0;
           case 1:
-            return _extends({}, filteredSubGroups[0], {
-              icon: undefined
-            });
+            return {
+              ...filteredSubGroups[0],
+              icon: void 0
+            };
           default:
-            return _extends({}, group, {
+            return {
+              ...group,
               subGroups: filteredSubGroups
-            });
+            };
         }
       }
-      return groupsToSkip != null && groupsToSkip.includes(group.id) ? undefined : group;
+      return groupsToSkip?.includes(group.id) ? void 0 : group;
     }).filter(itemIsParameterGroup);
     return cleanGroups;
   }, [groups, items, renderEmptyGroups]);
-  var tabs = useMemo(function () {
-    return (visibleGroups == null ? void 0 : visibleGroups.map(function (group) {
-      return {
-        label: group.name,
-        icon: group.icon
-      };
+  const tabs = useMemo(() => {
+    return visibleGroups?.map((group) => ({
+      label: group.name,
+      icon: group.icon
     })) || [];
   }, [visibleGroups]);
   return {
-    visibleGroups: visibleGroups,
-    tabs: tabs,
-    defaultTab: defaultTab
+    visibleGroups,
+    tabs,
+    defaultTab
   };
-};
+};
+export {
+  useGroups
+};

package/dist/FactorValue/Parameter/utils.d.ts

@@ -1,5 +1,5 @@
-import { type ParameterGroup } from '../../Factors.types';
-import { type DividerItem, type DropdownItem, type MixedDropdownItemProps, type ParameterDropdownTitleProps, type TitleItem } from './Parameter.types';
+import { ParameterGroup } from '../../Factors.types';
+import { DividerItem, DropdownItem, MixedDropdownItemProps, ParameterDropdownTitleProps, TitleItem } from './Parameter.types';
 export declare const groupItems: (dropdownItems: DropdownItem<ParameterGroup>[], activeGroup: ParameterGroup | undefined) => (DropdownItem<ParameterGroup> | TitleItem | DividerItem)[];
 export declare const isListTitle: (element?: MixedDropdownItemProps) => element is ParameterDropdownTitleProps;
 export declare const isDivider: (item: MixedDropdownItemProps | TitleItem | DividerItem) => item is DividerItem;

package/dist/FactorValue/Parameter/utils.js

@@ -1,24 +1,24 @@
-var NO_GROUP_NAME = 'NO_GROUP_NAME';
-export var groupItems = function groupItems(dropdownItems, activeGroup) {
-  var itemsNumber = dropdownItems.length;
-  var groupedItems = {};
-  var resultItems = [];
-  for (var i = 0; i < itemsNumber; i += 1) {
-    var item = dropdownItems[i];
-    var groupName = item.item.groupName || NO_GROUP_NAME;
-    var group = groupedItems[groupName] || [];
+const NO_GROUP_NAME = "NO_GROUP_NAME";
+const groupItems = (dropdownItems, activeGroup) => {
+  const itemsNumber = dropdownItems.length;
+  const groupedItems = {};
+  let resultItems = [];
+  for (let i = 0; i < itemsNumber; i += 1) {
+    const item = dropdownItems[i];
+    const groupName = item.item.groupName || NO_GROUP_NAME;
+    const group = groupedItems[groupName] || [];
     group.push(item);
     groupedItems[groupName] = group;
   }
-  Object.keys(groupedItems).forEach(function (key, index) {
+  Object.keys(groupedItems).forEach((key, index) => {
     if (key !== NO_GROUP_NAME && !activeGroup) {
       if (index > 0) {
         resultItems.push({
-          type: 'divider'
+          type: "divider"
         });
       }
       resultItems.push({
-        type: 'title',
+        type: "title",
         title: key
       });
     }
@@ -26,9 +26,14 @@ export var groupItems = function groupItems(dropdownItems, activeGroup) {
   });
   return resultItems;
 };
-export var isListTitle = function isListTitle(element) {
-  return element.title !== undefined;
+const isListTitle = (element) => {
+  return element.title !== void 0;
+};
+const isDivider = (item) => {
+  return item.type === "divider";
+};
+export {
+  groupItems,
+  isDivider,
+  isListTitle
 };
-export var isDivider = function isDivider(item) {
-  return item.type === 'divider';
-};

package/dist/FactorValue/RelativeDate/RelativeDate.const.d.ts

@@ -1,4 +1,4 @@
-import { type RelativeDateUnit, type RelativeTimeRelation } from '../../Factors.types';
+import { RelativeDateUnit, RelativeTimeRelation } from '../../Factors.types';
 export declare const INTERVALS: RelativeDateUnit[];
 export declare const BEFORE: RelativeTimeRelation;
 export declare const AFTER: RelativeTimeRelation;

package/dist/FactorValue/RelativeDate/RelativeDate.const.js

@@ -1,5 +1,12 @@
-export var INTERVALS = ['SECONDS', 'MINUTES', 'HOURS', 'DAYS', 'WEEKS', 'MONTHS', 'YEARS'];
-export var BEFORE = 'BEFORE';
-export var AFTER = 'AFTER';
-export var TIME_RELATIONS = [BEFORE, AFTER];
-export var DEFAULT_VALUE = 1;
+const INTERVALS = ["SECONDS", "MINUTES", "HOURS", "DAYS", "WEEKS", "MONTHS", "YEARS"];
+const BEFORE = "BEFORE";
+const AFTER = "AFTER";
+const TIME_RELATIONS = [BEFORE, AFTER];
+const DEFAULT_VALUE = 1;
+export {
+  AFTER,
+  BEFORE,
+  DEFAULT_VALUE,
+  INTERVALS,
+  TIME_RELATIONS
+};

package/dist/FactorValue/RelativeDate/RelativeDate.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
-import { type FactorValueComponentProps } from '../../Factors.types';
+import { default as React } from 'react';
+import { FactorValueComponentProps } from '../../Factors.types';
 declare const RelativeDateInput: ({ value, onChange, texts: allTexts, opened, onActivate, error, allowClear, readOnly, triggerValueFormatter, getPopupContainerOverride, availableUnits, uncontrolledComponent, }: FactorValueComponentProps) => React.JSX.Element;
 export default RelativeDateInput;

package/dist/FactorValue/RelativeDate/RelativeDate.js

@@ -1,114 +1,83 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-import { useTheme } from '@synerise/ds-core';
-import Dropdown from '@synerise/ds-dropdown';
-import Icon, { AngleDownS, Close3S } from '@synerise/ds-icon';
-import { getPopupContainer } from '@synerise/ds-utils';
-import { defaultTriggerModifier } from './RelativeDate.utils';
-import { RelativeDateDropdown } from './RelativeDateDropdown';
-import * as S from './RelativeDateDropdown.styles';
-var RelativeDateInput = function RelativeDateInput(_ref) {
-  var value = _ref.value,
-    onChange = _ref.onChange,
-    allTexts = _ref.texts,
-    opened = _ref.opened,
-    onActivate = _ref.onActivate,
-    error = _ref.error,
-    allowClear = _ref.allowClear,
-    _ref$readOnly = _ref.readOnly,
-    readOnly = _ref$readOnly === void 0 ? false : _ref$readOnly,
-    triggerValueFormatter = _ref.triggerValueFormatter,
-    getPopupContainerOverride = _ref.getPopupContainerOverride,
-    availableUnits = _ref.availableUnits,
-    uncontrolledComponent = _ref.uncontrolledComponent;
-  var _useState = useState(opened),
-    isOpen = _useState[0],
-    setIsOpen = _useState[1];
-  var _useState2 = useState(function () {
-      return value;
-    }),
-    localValue = _useState2[0],
-    setLocalValue = _useState2[1];
-  var theme = useTheme();
-  var texts = allTexts.relativeDate;
-  useEffect(function () {
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState, useEffect, useCallback, useMemo } from "react";
+import { useTheme } from "@synerise/ds-core";
+import Dropdown from "@synerise/ds-dropdown";
+import Icon, { AngleDownS, Close3S } from "@synerise/ds-icon";
+import { getPopupContainer } from "@synerise/ds-utils";
+import { defaultTriggerModifier } from "./RelativeDate.utils.js";
+import { RelativeDateDropdown } from "./RelativeDateDropdown.js";
+import { IconWrapper, ChevronIcon, ClearIcon, Trigger } from "./RelativeDateDropdown.styles.js";
+const RelativeDateInput = ({
+  value,
+  onChange,
+  texts: allTexts,
+  opened,
+  onActivate,
+  error,
+  allowClear,
+  readOnly = false,
+  triggerValueFormatter,
+  getPopupContainerOverride,
+  availableUnits,
+  uncontrolledComponent
+}) => {
+  const [isOpen, setIsOpen] = useState(opened);
+  const [localValue, setLocalValue] = useState(() => value);
+  const theme = useTheme();
+  const {
+    relativeDate: texts
+  } = allTexts;
+  useEffect(() => {
     if (!uncontrolledComponent) {
       setLocalValue(value);
     }
   }, [value, uncontrolledComponent]);
-  var handleOpenChange = useCallback(function (open) {
+  const handleOpenChange = useCallback((open) => {
     if (open) {
       onActivate && onActivate();
     }
     setIsOpen(open);
   }, [onActivate]);
-  var handleApply = useCallback(function (date) {
+  const handleApply = useCallback((date) => {
     onChange(date);
     handleOpenChange(false);
   }, [onChange, handleOpenChange]);
-  var handleClear = useCallback(function () {
-    onChange(undefined);
+  const handleClear = useCallback(() => {
+    onChange(void 0);
   }, [onChange]);
-  var handleOpen = useCallback(function () {
+  const handleOpen = useCallback(() => {
     setIsOpen(true);
   }, []);
-  var handleClose = useCallback(function () {
+  const handleClose = useCallback(() => {
     setIsOpen(false);
   }, []);
-  var triggerValue = useMemo(function () {
+  const triggerValue = useMemo(() => {
     if (!localValue) {
-      return undefined;
+      return void 0;
     }
     return triggerValueFormatter ? triggerValueFormatter(localValue) : defaultTriggerModifier(localValue, texts);
   }, [texts, localValue, triggerValueFormatter]);
-  var icon = useMemo(function () {
+  const icon = useMemo(() => {
     if (!localValue || !allowClear) {
-      return /*#__PURE__*/React.createElement(Icon, {
-        component: /*#__PURE__*/React.createElement(AngleDownS, null),
-        onClick: handleOpen
-      });
+      return /* @__PURE__ */ jsx(Icon, { component: /* @__PURE__ */ jsx(AngleDownS, {}), onClick: handleOpen });
     }
-    return /*#__PURE__*/React.createElement(S.IconWrapper, null, /*#__PURE__*/React.createElement(S.ChevronIcon, {
-      onClick: handleOpen,
-      component: /*#__PURE__*/React.createElement(AngleDownS, null)
-    }), /*#__PURE__*/React.createElement(S.ClearIcon, {
-      onClick: handleClear,
-      color: theme.palette['red-600'],
-      component: /*#__PURE__*/React.createElement(Close3S, null)
-    }));
+    return /* @__PURE__ */ jsxs(IconWrapper, { children: [
+      /* @__PURE__ */ jsx(ChevronIcon, { onClick: handleOpen, component: /* @__PURE__ */ jsx(AngleDownS, {}) }),
+      /* @__PURE__ */ jsx(ClearIcon, { onClick: handleClear, color: theme.palette["red-600"], component: /* @__PURE__ */ jsx(Close3S, {}) })
+    ] });
   }, [localValue, allowClear, handleClear, handleOpen, theme.palette]);
-  var trigger = useMemo(function () {
-    return /*#__PURE__*/React.createElement(S.Trigger, {
-      "data-testid": "ds-factors-relative-date-trigger",
-      error: error,
-      readOnly: true,
-      autoResize: {
-        minWidth: '123px',
-        stretchToFit: true
-      },
-      autoResizeProps: {
-        placeholderIsMinWidth: true
-      },
-      placeholder: texts.triggerPlaceholder,
-      value: triggerValue,
-      icon1: !readOnly ? icon : undefined
-    });
+  const trigger = useMemo(() => {
+    return /* @__PURE__ */ jsx(Trigger, { "data-testid": "ds-factors-relative-date-trigger", error, readOnly: true, autoResize: {
+      minWidth: "123px",
+      stretchToFit: true
+    }, autoResizeProps: {
+      placeholderIsMinWidth: true
+    }, placeholder: texts.triggerPlaceholder, value: triggerValue, icon1: !readOnly ? icon : void 0 });
   }, [error, triggerValue, readOnly, icon, texts.triggerPlaceholder]);
-  return readOnly ? trigger : /*#__PURE__*/React.createElement(Dropdown, {
-    getPopupContainer: getPopupContainerOverride || getPopupContainer,
-    open: isOpen,
-    onOpenChange: handleOpenChange,
-    asChild: false,
-    size: 420,
-    popoverProps: {
-      testId: 'factors-relative-date'
-    },
-    overlay: /*#__PURE__*/React.createElement(RelativeDateDropdown, {
-      onApply: handleApply,
-      onCancel: handleClose,
-      value: localValue,
-      texts: texts,
-      availableUnits: availableUnits
-    })
-  }, trigger);
+  return readOnly ? trigger : /* @__PURE__ */ jsx(Dropdown, { getPopupContainer: getPopupContainerOverride || getPopupContainer, open: isOpen, onOpenChange: handleOpenChange, asChild: false, size: 420, popoverProps: {
+    testId: "factors-relative-date"
+  }, overlay: /* @__PURE__ */ jsx(RelativeDateDropdown, { onApply: handleApply, onCancel: handleClose, value: localValue, texts, availableUnits }), children: trigger });
+};
+export {
+  RelativeDateInput as default
 };
-export default RelativeDateInput;

package/dist/FactorValue/RelativeDate/RelativeDate.utils.d.ts

@@ -1,3 +1,3 @@
-import { type RelativeDateFactorTexts, type RelativeDateFactorTextsString, type RelativeDateValueType } from '../../Factors.types';
+import { RelativeDateFactorTexts, RelativeDateFactorTextsString, RelativeDateValueType } from '../../Factors.types';
 export declare const getTranslation: (texts: RelativeDateFactorTextsString, key: string) => string;
 export declare const defaultTriggerModifier: (value: RelativeDateValueType, texts: RelativeDateFactorTexts) => string;

package/dist/FactorValue/RelativeDate/RelativeDate.utils.js

@@ -1,13 +1,17 @@
-import { RelativeDateKeysString } from '../../Factors.types';
-var isTextsKey = function isTextsKey(key) {
-  return [].concat(RelativeDateKeysString).includes(key);
+import { RelativeDateKeysString } from "../../Factors.types.js";
+const isTextsKey = (key) => {
+  return [...RelativeDateKeysString].includes(key);
 };
-export var getTranslation = function getTranslation(texts, key) {
-  var lowercaseKey = key.toLowerCase();
+const getTranslation = (texts, key) => {
+  const lowercaseKey = key.toLowerCase();
   return isTextsKey(lowercaseKey) ? texts[lowercaseKey] : key;
 };
-export var defaultTriggerModifier = function defaultTriggerModifier(value, texts) {
-  var relation = value.temporalModifier < 0 ? texts.before : texts.after;
-  var absValue = Math.abs(value.temporalModifier);
-  return absValue + " " + getTranslation(texts, value.temporalUnit).toLocaleLowerCase() + " " + relation.toLocaleLowerCase() + " " + texts.currentDatetime;
-};
+const defaultTriggerModifier = (value, texts) => {
+  const relation = value.temporalModifier < 0 ? texts.before : texts.after;
+  const absValue = Math.abs(value.temporalModifier);
+  return `${absValue} ${getTranslation(texts, value.temporalUnit).toLocaleLowerCase()} ${relation.toLocaleLowerCase()} ${texts.currentDatetime}`;
+};
+export {
+  defaultTriggerModifier,
+  getTranslation
+};

package/dist/FactorValue/RelativeDate/RelativeDateDropdown.d.ts

@@ -1,5 +1,5 @@
-import React from 'react';
-import { type RelativeDateFactorTexts, type RelativeDateUnit, type RelativeDateValueType } from '../../Factors.types';
+import { default as React } from 'react';
+import { RelativeDateFactorTexts, RelativeDateUnit, RelativeDateValueType } from '../../Factors.types';
 type RelativeDateDropdownProps = {
     value?: RelativeDateValueType;
     texts: RelativeDateFactorTexts;

package/dist/FactorValue/RelativeDate/RelativeDateDropdown.js

@@ -1,97 +1,66 @@
-import React, { useEffect, useMemo, useState } from 'react';
-import Button from '@synerise/ds-button';
-import { InputGroup } from '@synerise/ds-input';
-import InputNumber from '@synerise/ds-input-number';
-import Select from '@synerise/ds-select/dist/Select';
-import { AFTER, BEFORE, DEFAULT_VALUE, INTERVALS, TIME_RELATIONS } from './RelativeDate.const';
-import { getTranslation } from './RelativeDate.utils';
-import * as S from './RelativeDateDropdown.styles';
-var getRelationForModifier = function getRelationForModifier(value) {
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { useState, useEffect, useMemo } from "react";
+import Button from "@synerise/ds-button";
+import { InputGroup } from "@synerise/ds-input";
+import InputNumber from "@synerise/ds-input-number";
+import Select from "@synerise/ds-select/dist/Select";
+import { BEFORE, INTERVALS, DEFAULT_VALUE, TIME_RELATIONS, AFTER } from "./RelativeDate.const.js";
+import { getTranslation } from "./RelativeDate.utils.js";
+import { RelativeDateDropdownWrapper, RelativeDateCurrentLabel, RelativeDateDropdownFooter } from "./RelativeDateDropdown.styles.js";
+const getRelationForModifier = (value) => {
   return value < 0 ? BEFORE : AFTER;
 };
-export var RelativeDateDropdown = function RelativeDateDropdown(_ref) {
-  var onApply = _ref.onApply,
-    onCancel = _ref.onCancel,
-    relativeDateValue = _ref.value,
-    texts = _ref.texts,
-    availableUnits = _ref.availableUnits;
-  var defaultTimeRelation = relativeDateValue ? getRelationForModifier(relativeDateValue.temporalModifier) : BEFORE;
-  var defaultTemporalUnit = (relativeDateValue == null ? void 0 : relativeDateValue.temporalUnit) || (availableUnits != null && availableUnits.length ? availableUnits : INTERVALS)[0];
-  var defaultModifier = Math.abs((relativeDateValue == null ? void 0 : relativeDateValue.temporalModifier) || DEFAULT_VALUE);
-  var _useState = useState(defaultTimeRelation),
-    timeRelation = _useState[0],
-    setTimeRelation = _useState[1];
-  var _useState2 = useState(defaultTemporalUnit),
-    temporalUnit = _useState2[0],
-    setTemporalUnit = _useState2[1];
-  var _useState3 = useState(defaultModifier),
-    temporalModifier = _useState3[0],
-    setTemporalModifier = _useState3[1];
-  useEffect(function () {
+const RelativeDateDropdown = ({
+  onApply,
+  onCancel,
+  value: relativeDateValue,
+  texts,
+  availableUnits
+}) => {
+  const defaultTimeRelation = relativeDateValue ? getRelationForModifier(relativeDateValue.temporalModifier) : BEFORE;
+  const defaultTemporalUnit = relativeDateValue?.temporalUnit || (availableUnits?.length ? availableUnits : INTERVALS)[0];
+  const defaultModifier = Math.abs(relativeDateValue?.temporalModifier || DEFAULT_VALUE);
+  const [timeRelation, setTimeRelation] = useState(defaultTimeRelation);
+  const [temporalUnit, setTemporalUnit] = useState(defaultTemporalUnit);
+  const [temporalModifier, setTemporalModifier] = useState(defaultModifier);
+  useEffect(() => {
     setTimeRelation(relativeDateValue ? getRelationForModifier(relativeDateValue.temporalModifier) : BEFORE);
-    setTemporalUnit((relativeDateValue == null ? void 0 : relativeDateValue.temporalUnit) || INTERVALS[0]);
-    setTemporalModifier(Math.abs((relativeDateValue == null ? void 0 : relativeDateValue.temporalModifier) || DEFAULT_VALUE));
+    setTemporalUnit(relativeDateValue?.temporalUnit || INTERVALS[0]);
+    setTemporalModifier(Math.abs(relativeDateValue?.temporalModifier || DEFAULT_VALUE));
   }, [relativeDateValue]);
-  var isApplyEnabled = temporalModifier && temporalUnit !== undefined;
-  var handleApply = function handleApply() {
-    var finalModifier = timeRelation === BEFORE ? -temporalModifier : temporalModifier;
+  const isApplyEnabled = temporalModifier && temporalUnit !== void 0;
+  const handleApply = () => {
+    const finalModifier = timeRelation === BEFORE ? -temporalModifier : temporalModifier;
     isApplyEnabled && onApply({
       temporalModifier: finalModifier,
-      temporalUnit: temporalUnit
+      temporalUnit
     });
   };
-  var temporalUnitOptions = useMemo(function () {
-    return (availableUnits != null && availableUnits.length ? availableUnits : INTERVALS).map(function (intervalOption) {
-      return /*#__PURE__*/React.createElement(Select.Option, {
-        key: intervalOption,
-        value: intervalOption
-      }, getTranslation(texts, intervalOption));
-    });
+  const temporalUnitOptions = useMemo(() => {
+    return (availableUnits?.length ? availableUnits : INTERVALS).map((intervalOption) => /* @__PURE__ */ jsx(Select.Option, { value: intervalOption, children: getTranslation(texts, intervalOption) }, intervalOption));
   }, [texts, availableUnits]);
-  var timeRelationOptions = useMemo(function () {
-    return TIME_RELATIONS.map(function (option) {
-      return /*#__PURE__*/React.createElement(Select.Option, {
-        key: option,
-        value: option
-      }, getTranslation(texts, option));
-    });
+  const timeRelationOptions = useMemo(() => {
+    return TIME_RELATIONS.map((option) => /* @__PURE__ */ jsx(Select.Option, { value: option, children: getTranslation(texts, option) }, option));
   }, [texts]);
-  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(S.RelativeDateDropdownWrapper, {
-    "data-testid": "ds-factors-relative-date-dropdown"
-  }, /*#__PURE__*/React.createElement(InputGroup, {
-    resetMargin: true,
-    compact: true
-  }, /*#__PURE__*/React.createElement(InputNumber, {
-    "data-testid": "ds-factors-relative-date-modifier",
-    defaultValue: 1,
-    min: 1,
-    raw: true,
-    value: temporalModifier,
-    onChange: function onChange(newTemporalModifier) {
-      return newTemporalModifier && setTemporalModifier(newTemporalModifier);
-    }
-  }), /*#__PURE__*/React.createElement(Select, {
-    value: temporalUnit,
-    "data-testid": "ds-factors-relative-date-unit",
-    defaultValue: defaultTemporalUnit,
-    onChange: function onChange(newTemporalUnit) {
-      setTemporalUnit(newTemporalUnit);
-    },
-    dropdownMatchSelectWidth: false
-  }, temporalUnitOptions)), /*#__PURE__*/React.createElement(Select, {
-    value: timeRelation,
-    "data-testid": "ds-factors-relative-date-relation",
-    defaultValue: defaultTimeRelation,
-    onChange: function onChange(newTimeRelation) {
-      setTimeRelation(newTimeRelation);
-    },
-    dropdownMatchSelectWidth: false
-  }, timeRelationOptions), /*#__PURE__*/React.createElement(S.RelativeDateCurrentLabel, null, texts.currentDatetime)), /*#__PURE__*/React.createElement(S.RelativeDateDropdownFooter, null, /*#__PURE__*/React.createElement(Button, {
-    type: "ghost",
-    onClick: onCancel
-  }, texts.cancel), /*#__PURE__*/React.createElement(Button, {
-    type: "primary",
-    onClick: handleApply,
-    disabled: !isApplyEnabled
-  }, texts.apply)));
-};
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs(RelativeDateDropdownWrapper, { "data-testid": "ds-factors-relative-date-dropdown", children: [
+      /* @__PURE__ */ jsxs(InputGroup, { resetMargin: true, compact: true, children: [
+        /* @__PURE__ */ jsx(InputNumber, { "data-testid": "ds-factors-relative-date-modifier", defaultValue: 1, min: 1, raw: true, value: temporalModifier, onChange: (newTemporalModifier) => newTemporalModifier && setTemporalModifier(newTemporalModifier) }),
+        /* @__PURE__ */ jsx(Select, { value: temporalUnit, "data-testid": "ds-factors-relative-date-unit", defaultValue: defaultTemporalUnit, onChange: (newTemporalUnit) => {
+          setTemporalUnit(newTemporalUnit);
+        }, dropdownMatchSelectWidth: false, children: temporalUnitOptions })
+      ] }),
+      /* @__PURE__ */ jsx(Select, { value: timeRelation, "data-testid": "ds-factors-relative-date-relation", defaultValue: defaultTimeRelation, onChange: (newTimeRelation) => {
+        setTimeRelation(newTimeRelation);
+      }, dropdownMatchSelectWidth: false, children: timeRelationOptions }),
+      /* @__PURE__ */ jsx(RelativeDateCurrentLabel, { children: texts.currentDatetime })
+    ] }),
+    /* @__PURE__ */ jsxs(RelativeDateDropdownFooter, { children: [
+      /* @__PURE__ */ jsx(Button, { type: "ghost", onClick: onCancel, children: texts.cancel }),
+      /* @__PURE__ */ jsx(Button, { type: "primary", onClick: handleApply, disabled: !isApplyEnabled, children: texts.apply })
+    ] })
+  ] });
+};
+export {
+  RelativeDateDropdown
+};

package/dist/FactorValue/RelativeDate/RelativeDateDropdown.styles.d.ts

@@ -1,8 +1,8 @@
-import { type StyledInput } from '@synerise/ds-input';
-export declare const RelativeDateDropdownWrapper: import("styled-components").StyledComponent<"div", any, {}, never>;
-export declare const RelativeDateDropdownFooter: import("styled-components").StyledComponent<"div", any, {}, never>;
-export declare const RelativeDateCurrentLabel: import("styled-components").StyledComponent<"div", any, {}, never>;
-export declare const IconWrapper: import("styled-components").StyledComponent<"div", any, {}, never>;
-export declare const ClearIcon: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("@synerise/ds-icon").BaseIconProps & Omit<import("react").HTMLAttributes<HTMLDivElement>, keyof import("@synerise/ds-icon").BaseIconProps> & import("@synerise/ds-utils").DataAttributes & import("react").RefAttributes<HTMLDivElement>>, any, {}, never>;
-export declare const ChevronIcon: import("styled-components").StyledComponent<import("react").ForwardRefExoticComponent<import("@synerise/ds-icon").BaseIconProps & Omit<import("react").HTMLAttributes<HTMLDivElement>, keyof import("@synerise/ds-icon").BaseIconProps> & import("@synerise/ds-utils").DataAttributes & import("react").RefAttributes<HTMLDivElement>>, any, {}, never>;
+import { StyledInput } from '@synerise/ds-input';
+export declare const RelativeDateDropdownWrapper: import('styled-components').StyledComponent<"div", any, {}, never>;
+export declare const RelativeDateDropdownFooter: import('styled-components').StyledComponent<"div", any, {}, never>;
+export declare const RelativeDateCurrentLabel: import('styled-components').StyledComponent<"div", any, {}, never>;
+export declare const IconWrapper: import('styled-components').StyledComponent<"div", any, {}, never>;
+export declare const ClearIcon: import('styled-components').StyledComponent<import('react').ForwardRefExoticComponent<import('@synerise/ds-icon').BaseIconProps & Omit<import('react').HTMLAttributes<HTMLDivElement>, keyof import('@synerise/ds-icon').BaseIconProps> & import('@synerise/ds-utils').DataAttributes & import('react').RefAttributes<HTMLDivElement>>, any, {}, never>;
+export declare const ChevronIcon: import('styled-components').StyledComponent<import('react').ForwardRefExoticComponent<import('@synerise/ds-icon').BaseIconProps & Omit<import('react').HTMLAttributes<HTMLDivElement>, keyof import('@synerise/ds-icon').BaseIconProps> & import('@synerise/ds-utils').DataAttributes & import('react').RefAttributes<HTMLDivElement>>, any, {}, never>;
 export declare const Trigger: StyledInput;