@monolith-forensics/monolith-ui 1.8.1-dev.2 → 1.8.1-dev.4

package/dist/SuperDatePicker/SuperDatePicker.lib.js

@@ -0,0 +1,206 @@
+import moment from "moment";
+export const resolveNow = (utc) => (utc ? moment.utc() : moment());
+export const serializeMoment = (value, utc) => {
+    const next = utc ? value.clone().utc() : value.clone();
+    return next.toISOString();
+};
+export const createRange = (start, end, utc) => ({
+    start: serializeMoment(start, utc),
+    end: serializeMoment(end, utc),
+});
+export const makeCommonRange = (utc, label, getRange) => ({
+    label,
+    getRange: () => {
+        const { start, end } = getRange(resolveNow(utc));
+        return createRange(start, end, utc);
+    },
+});
+export const getDefaultCommonRangeGroups = (utc) => {
+    return [
+        {
+            label: "Days",
+            ranges: [
+                makeCommonRange(utc, "Today", (now) => ({
+                    start: now.clone().startOf("day"),
+                    end: now.clone().endOf("day"),
+                })),
+                makeCommonRange(utc, "Yesterday", (now) => ({
+                    start: now.clone().subtract(1, "day").startOf("day"),
+                    end: now.clone().subtract(1, "day").endOf("day"),
+                })),
+                makeCommonRange(utc, "Day to date", (now) => ({
+                    start: now.clone().startOf("day"),
+                    end: now,
+                })),
+            ],
+        },
+        {
+            label: "Weeks",
+            ranges: [
+                makeCommonRange(utc, "This week", (now) => ({
+                    start: now.clone().startOf("week"),
+                    end: now.clone().endOf("week"),
+                })),
+                makeCommonRange(utc, "Week to date", (now) => ({
+                    start: now.clone().startOf("week"),
+                    end: now,
+                })),
+                makeCommonRange(utc, "Last week", (now) => ({
+                    start: now.clone().subtract(1, "week").startOf("week"),
+                    end: now.clone().subtract(1, "week").endOf("week"),
+                })),
+            ],
+        },
+        {
+            label: "Months",
+            ranges: [
+                makeCommonRange(utc, "This month", (now) => ({
+                    start: now.clone().startOf("month"),
+                    end: now.clone().endOf("month"),
+                })),
+                makeCommonRange(utc, "Month to date", (now) => ({
+                    start: now.clone().startOf("month"),
+                    end: now,
+                })),
+                makeCommonRange(utc, "Last month", (now) => ({
+                    start: now.clone().subtract(1, "month").startOf("month"),
+                    end: now.clone().subtract(1, "month").endOf("month"),
+                })),
+            ],
+        },
+        {
+            label: "Years",
+            ranges: [
+                makeCommonRange(utc, "This year", (now) => ({
+                    start: now.clone().startOf("year"),
+                    end: now.clone().endOf("year"),
+                })),
+                makeCommonRange(utc, "Year to date", (now) => ({
+                    start: now.clone().startOf("year"),
+                    end: now,
+                })),
+                makeCommonRange(utc, "Last year", (now) => ({
+                    start: now.clone().subtract(1, "year").startOf("year"),
+                    end: now.clone().subtract(1, "year").endOf("year"),
+                })),
+            ],
+        },
+    ];
+};
+export const getAdditionalCommonRangeGroups = (utc) => {
+    return [
+        {
+            label: "Quarters",
+            ranges: [
+                makeCommonRange(utc, "This quarter", (now) => ({
+                    start: now.clone().startOf("quarter"),
+                    end: now.clone().endOf("quarter"),
+                })),
+                makeCommonRange(utc, "Quarter to date", (now) => ({
+                    start: now.clone().startOf("quarter"),
+                    end: now,
+                })),
+                makeCommonRange(utc, "Last quarter", (now) => ({
+                    start: now.clone().subtract(1, "quarter").startOf("quarter"),
+                    end: now.clone().subtract(1, "quarter").endOf("quarter"),
+                })),
+                makeCommonRange(utc, "Last 4 quarters", (now) => ({
+                    start: now.clone().subtract(4, "quarter").startOf("quarter"),
+                    end: now.clone().subtract(1, "quarter").endOf("quarter"),
+                })),
+            ],
+        },
+        {
+            label: "Rolling windows",
+            ranges: [
+                makeCommonRange(utc, "Last 15 minutes", (now) => ({
+                    start: now.clone().subtract(15, "minutes"),
+                    end: now,
+                })),
+                makeCommonRange(utc, "Last 30 minutes", (now) => ({
+                    start: now.clone().subtract(30, "minutes"),
+                    end: now,
+                })),
+                makeCommonRange(utc, "Last hour", (now) => ({
+                    start: now.clone().subtract(1, "hour"),
+                    end: now,
+                })),
+                makeCommonRange(utc, "Last 24 hours", (now) => ({
+                    start: now.clone().subtract(24, "hours"),
+                    end: now,
+                })),
+                makeCommonRange(utc, "Last 7 days", (now) => ({
+                    start: now.clone().subtract(7, "days"),
+                    end: now,
+                })),
+                makeCommonRange(utc, "Last 2 weeks", (now) => ({
+                    start: now.clone().subtract(2, "weeks"),
+                    end: now,
+                })),
+                makeCommonRange(utc, "Last 4 weeks", (now) => ({
+                    start: now.clone().subtract(4, "weeks"),
+                    end: now,
+                })),
+                makeCommonRange(utc, "Last 30 days", (now) => ({
+                    start: now.clone().subtract(30, "days"),
+                    end: now,
+                })),
+                makeCommonRange(utc, "Last 90 days", (now) => ({
+                    start: now.clone().subtract(90, "days"),
+                    end: now,
+                })),
+                makeCommonRange(utc, "Last 6 months", (now) => ({
+                    start: now.clone().subtract(6, "months"),
+                    end: now,
+                })),
+                makeCommonRange(utc, "Last 12 months", (now) => ({
+                    start: now.clone().subtract(12, "months"),
+                    end: now,
+                })),
+                makeCommonRange(utc, "Last 2 years", (now) => ({
+                    start: now.clone().subtract(2, "years"),
+                    end: now,
+                })),
+                makeCommonRange(utc, "Last 3 years", (now) => ({
+                    start: now.clone().subtract(3, "years"),
+                    end: now,
+                })),
+                makeCommonRange(utc, "Last 5 years", (now) => ({
+                    start: now.clone().subtract(5, "years"),
+                    end: now,
+                })),
+                makeCommonRange(utc, "Last 10 years", (now) => ({
+                    start: now.clone().subtract(10, "years"),
+                    end: now,
+                })),
+            ],
+        },
+    ];
+};
+export const parseRangeMoment = (value, utc) => {
+    if (!value)
+        return null;
+    const parsed = utc ? moment.utc(value) : moment(value);
+    return parsed.isValid() ? parsed : null;
+};
+export const momentToCalendarDate = (value, utc) => {
+    const parsed = parseRangeMoment(value, utc);
+    if (!parsed)
+        return undefined;
+    if (!utc)
+        return parsed.toDate();
+    return new Date(parsed.year(), parsed.month(), parsed.date(), parsed.hour(), parsed.minute(), parsed.second(), parsed.millisecond());
+};
+export const calendarDateToMoment = (value, utc) => {
+    if (!utc)
+        return moment(value);
+    return moment.utc({
+        year: value.getFullYear(),
+        month: value.getMonth(),
+        date: value.getDate(),
+        hour: value.getHours(),
+        minute: value.getMinutes(),
+        second: value.getSeconds(),
+        millisecond: value.getMilliseconds(),
+    });
+};

package/dist/SuperDatePicker/SuperDatePicker.styled.d.ts

@@ -0,0 +1,60 @@
+import { Size, Variant } from "../core";
+export declare const StyledContainer: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("styled-components").FastOmit<import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>>, never>, {
+    $width?: string | number;
+}>> & string;
+export declare const StyledInput: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    size: Size;
+    variant: Variant;
+    $disabled?: boolean;
+    $active?: boolean;
+    $clearable?: boolean;
+}>> & string;
+export declare const SegmentButton: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, {
+    size: Size;
+    $grow?: boolean;
+    $iconOnly?: boolean;
+}>> & string;
+export declare const EndpointInputTarget: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    size: Size;
+}>> & string;
+export declare const TriggerIcon: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {
+    size: Size;
+}>> & string;
+export declare const RangeSeparator: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, {
+    size: Size;
+}>> & string;
+export declare const TriggerActions: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>> & string;
+export declare const PopoverContent: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components/dist/types").Substitute<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+    $width?: number;
+}>> & string;
+export declare const EndpointPopoverContent: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "$width"> & {
+    $width?: number;
+}, never>> & string;
+export declare const QuickRangePanel: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const QuickRangeSection: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const QuickSelectRow: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const CommonRangesGrid: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const CommonRangesSection: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>, never>> & string;
+export declare const CommonRangesScroll: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const CommonRangeGroup: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const CommonRangeGroupLabel: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const PanelTitle: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const PresetButton: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").ButtonHTMLAttributes<HTMLButtonElement> & {
+    ref?: import("react").RefObject<HTMLButtonElement>;
+    children?: import("react").ReactNode | string;
+    className?: string;
+    loading?: boolean;
+    leftSection?: import("react").ReactNode;
+    rightSection?: import("react").ReactNode;
+    href?: string | null;
+    download?: string | null;
+    fullWidth?: boolean;
+    size?: Size;
+    variant?: Variant;
+    color?: import("../Button").ButtonColor;
+    disabled?: boolean;
+    selected?: boolean;
+    justify?: "start" | "center" | "end";
+    onClick?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+}, never>> & string & Omit<import("react").FC<import("../Button").ButtonProps>, keyof import("react").Component<any, {}, any>>;
+export declare const CalendarShell: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;

package/dist/SuperDatePicker/SuperDatePicker.styled.js

@@ -0,0 +1,256 @@
+import styled from "styled-components";
+import { Button } from "../Button";
+import { getControlSizeTokens } from "../core";
+export const StyledContainer = styled.div.attrs({
+    className: "mfui-SuperDatePicker",
+}) `
+  width: ${({ $width }) => {
+    if ($width === undefined || $width === null)
+        return "max-content";
+    return typeof $width === "number" ? `${$width}px` : $width;
+}};
+`;
+export const StyledInput = styled.div `
+  position: relative;
+  display: flex;
+  align-items: center;
+  width: 100%;
+  min-width: max-content;
+  height: ${({ size }) => `${getControlSizeTokens(size).height}px`};
+  padding-right: ${({ size, $clearable }) => $clearable ? `${getControlSizeTokens(size).adornmentWidth}px` : 0};
+  border-radius: 5px;
+  border: 1px solid
+    ${({ theme, variant }) => variant === "filled" || variant === "text"
+    ? "transparent"
+    : theme.palette.input.border};
+  outline: none;
+  background: ${({ theme, variant }) => variant === "text" ? "transparent" : theme.palette.input.background};
+  color: ${({ theme }) => theme.palette.text.primary};
+  font-family: ${({ theme }) => theme.typography.fontFamily};
+  font-size: ${({ size }) => `${getControlSizeTokens(size).fontSize}px`};
+  text-align: left;
+  transition: border 0.1s ease-in-out;
+  opacity: ${({ $disabled }) => ($disabled ? 0.5 : 1)};
+  cursor: ${({ $disabled }) => ($disabled ? "not-allowed" : "default")};
+
+  ${({ $disabled }) => $disabled &&
+    `
+    > * {
+      pointer-events: none;
+    }
+  `}
+
+  ${({ $active, theme }) => $active &&
+    `
+    border-color: ${theme.palette.primary.main};
+  `}
+
+  &:focus-visible,
+  &:focus,
+  &:focus-within {
+    border-color: ${({ theme }) => theme.palette.primary.main};
+  }
+`;
+export const SegmentButton = styled.button `
+  display: flex;
+  align-items: center;
+  justify-content: ${({ $iconOnly }) => ($iconOnly ? "center" : "flex-start")};
+  gap: ${({ size }) => `${getControlSizeTokens(size).iconGap}px`};
+  min-width: 0;
+  flex: 0 0 auto;
+  width: ${({ size, $iconOnly }) => $iconOnly ? `${getControlSizeTokens(size).adornmentWidth}px` : "auto"};
+  height: 100%;
+  padding: ${({ size, $iconOnly }) => $iconOnly ? "0" : `0 ${getControlSizeTokens(size).inputPaddingX}px`};
+  border: none;
+  border-right: ${({ theme, $iconOnly }) => $iconOnly ? `1px solid ${theme.palette.divider}` : "none"};
+  outline: none;
+  background: transparent;
+  color: ${({ theme }) => theme.palette.text.primary};
+  font: inherit;
+  cursor: pointer;
+  text-align: left;
+
+  &:hover,
+  &:focus-visible,
+  &[data-active="true"] {
+    background: ${({ theme }) => theme.palette.action.hover};
+  }
+
+  &:first-child {
+    border-radius: 4px 0 0 4px;
+  }
+`;
+export const EndpointInputTarget = styled.div `
+  display: flex;
+  align-items: center;
+  flex: 0 0 auto;
+  height: 100%;
+
+  .mfui-DateInput {
+    width: max-content;
+  }
+
+  .mfui-DateInput .input-container {
+    width: max-content;
+    min-width: max-content;
+    height: calc(
+      ${({ size }) => `${getControlSizeTokens(size).height}px`} - 2px
+    );
+    border: none;
+    border-radius: 0;
+    background: transparent;
+    padding: 0 ${({ size }) => `${getControlSizeTokens(size).inputPaddingX}px`};
+  }
+
+  &:hover .mfui-DateInput .input-container,
+  &[data-active="true"] .mfui-DateInput .input-container {
+    background: ${({ theme }) => theme.palette.action.hover};
+  }
+
+  .mfui-DateInput .input-container:focus,
+  .mfui-DateInput .input-container:focus-within {
+    border: none;
+  }
+`;
+export const TriggerIcon = styled.span `
+  display: inline-flex;
+  align-items: center;
+  color: ${({ theme }) => theme.palette.text.secondary};
+
+  svg {
+    width: ${({ size }) => `${getControlSizeTokens(size).iconSize}px`};
+    height: ${({ size }) => `${getControlSizeTokens(size).iconSize}px`};
+  }
+`;
+export const RangeSeparator = styled.span `
+  flex: 0 0 auto;
+  color: ${({ theme }) => theme.palette.text.secondary};
+  font-size: ${({ size }) => `${getControlSizeTokens(size).fontSize}px`};
+  line-height: 1;
+  user-select: none;
+`;
+export const TriggerActions = styled.span `
+  position: absolute;
+  right: 0;
+  top: 0;
+  display: flex;
+  height: 100%;
+`;
+export const PopoverContent = styled.div `
+  width: ${({ $width }) => ($width ? `${$width}px` : "fit-content")};
+  max-width: calc(100vw - 32px);
+`;
+export const EndpointPopoverContent = styled(PopoverContent) `
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+`;
+export const QuickRangePanel = styled.div `
+  display: flex;
+  flex-direction: column;
+  width: 342px;
+  max-width: calc(100vw - 32px);
+  max-height: min(520px, calc(100vh - 80px));
+  overflow: hidden;
+`;
+export const QuickRangeSection = styled.div `
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  padding: 10px;
+
+  & + & {
+    border-top: 1px solid ${({ theme }) => theme.palette.divider};
+  }
+`;
+export const QuickSelectRow = styled.div `
+  display: grid;
+  grid-template-columns: 1fr 108px 1fr;
+  gap: 8px;
+  align-items: start;
+`;
+export const CommonRangesGrid = styled.div `
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+`;
+export const CommonRangesSection = styled(QuickRangeSection) `
+  flex: 1 1 auto;
+  min-height: 0;
+`;
+export const CommonRangesScroll = styled.div `
+  flex: 1 1 auto;
+  min-height: 0;
+  overflow-y: auto;
+  overscroll-behavior: contain;
+  padding-right: 4px;
+`;
+export const CommonRangeGroup = styled.div `
+  display: flex;
+  flex-direction: column;
+  gap: 5px;
+
+  & + & {
+    margin-top: 8px;
+  }
+`;
+export const CommonRangeGroupLabel = styled.div `
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  color: ${({ theme }) => theme.palette.text.secondary};
+  font-size: 10px;
+  font-weight: 700;
+  line-height: 1.2;
+  text-transform: uppercase;
+
+  &::after {
+    content: "";
+    flex: 1 1 auto;
+    border-top: 1px solid ${({ theme }) => theme.palette.divider};
+    opacity: 0.7;
+  }
+`;
+export const PanelTitle = styled.div `
+  font-size: 11px;
+  font-weight: 700;
+  line-height: 1.2;
+  text-transform: uppercase;
+  color: ${({ theme }) => theme.palette.text.secondary};
+  margin-bottom: 4px;
+`;
+export const PresetButton = styled(Button) `
+  display: flex;
+  align-items: center;
+  width: 100%;
+  padding: 0;
+  border: none;
+  border-radius: 4px;
+  background: transparent;
+  color: ${({ theme }) => theme.palette.primary.main};
+  font: inherit;
+  font-size: 12px;
+  text-align: left;
+  cursor: pointer;
+  justify-content: flex-start;
+
+  &:hover,
+  &:focus-visible {
+    background: transparent;
+    color: ${({ theme }) => theme.palette.primary.main};
+    outline: none;
+    text-decoration: underline;
+  }
+
+  .inner-span {
+    justify-content: flex-start !important;
+  }
+`;
+export const CalendarShell = styled.div `
+  display: flex;
+  justify-content: center;
+  padding: 8px;
+  overflow-x: auto;
+  border: 1px solid ${({ theme }) => theme.palette.divider};
+  border-radius: 5px;
+  background: ${({ theme }) => theme.palette.background.paper};
+`;

package/dist/SuperDatePicker/SuperDatePicker.types.d.ts

@@ -0,0 +1,48 @@
+import type { CSSProperties, ReactNode } from "react";
+import type { FormatOptions } from "../DateInput/DateInput";
+import type { Size, Variant } from "../core";
+export type SuperDatePickerValue = {
+    start?: string | null;
+    end?: string | null;
+};
+export type SuperDatePickerPreset = {
+    label: string;
+    getRange: () => Required<SuperDatePickerValue>;
+};
+export type SuperDatePickerChangeMeta = {
+    source: "apply" | "clear" | "preset";
+    preset?: SuperDatePickerPreset;
+};
+export type SuperDatePickerProps = {
+    className?: string;
+    style?: CSSProperties;
+    defaultValue?: SuperDatePickerValue;
+    value?: SuperDatePickerValue;
+    onChange?: (value: SuperDatePickerValue, meta: SuperDatePickerChangeMeta) => void;
+    label?: string;
+    description?: ReactNode;
+    placeholder?: string;
+    startLabel?: string;
+    endLabel?: string;
+    format?: FormatOptions;
+    size?: Size;
+    variant?: Variant;
+    required?: boolean;
+    clearable?: boolean;
+    disabled?: boolean;
+    error?: string;
+    width?: string | number;
+    min?: Date;
+    max?: Date;
+    timeIntervalMinutes?: number;
+    utc?: boolean;
+    presets?: SuperDatePickerPreset[];
+};
+export type Endpoint = "start" | "end";
+export type OpenSegment = "quick" | Endpoint | null;
+export type QuickDirection = "last" | "next";
+export type QuickUnit = "minutes" | "hours" | "days" | "weeks" | "months" | "years";
+export type CommonRangeGroupConfig = {
+    label: string;
+    ranges: SuperDatePickerPreset[];
+};

package/dist/SuperDatePicker/SuperDatePicker.types.js

@@ -0,0 +1 @@
+export {};

package/dist/SuperDatePicker/components/CommonPresetGroups.d.ts

@@ -0,0 +1,7 @@
+import type { CommonRangeGroupConfig, SuperDatePickerPreset } from "../SuperDatePicker.types";
+type CommonPresetGroupsProps = {
+    groups: CommonRangeGroupConfig[];
+    onPresetClick: (preset: SuperDatePickerPreset) => void;
+};
+declare const CommonPresetGroups: ({ groups, onPresetClick, }: CommonPresetGroupsProps) => import("react/jsx-runtime").JSX.Element;
+export default CommonPresetGroups;

package/dist/SuperDatePicker/components/CommonPresetGroups.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { CommonRangeGroup, CommonRangeGroupLabel, CommonRangesGrid, CommonRangesScroll, PresetButton, } from "../SuperDatePicker.styled";
+const CommonPresetGroups = ({ groups, onPresetClick, }) => {
+    return (_jsx(CommonRangesScroll, { children: groups.map((group) => (_jsxs(CommonRangeGroup, { children: [_jsx(CommonRangeGroupLabel, { children: group.label }), _jsx(CommonRangesGrid, { children: group.ranges.map((preset) => (_jsx(PresetButton, { type: "button", variant: "text", color: "primary", size: "xxs", onClick: () => onPresetClick(preset), children: preset.label }, preset.label))) })] }, group.label))) }));
+};
+export default CommonPresetGroups;

package/dist/SuperDatePicker/components/EndpointCalendarDropdown.d.ts

@@ -0,0 +1,10 @@
+type EndpointCalendarDropdownProps = {
+    value?: string | null;
+    onChange: (date: Date | null) => void;
+    min?: Date;
+    max?: Date;
+    timeIntervalMinutes?: number;
+    utc: boolean;
+};
+declare const EndpointCalendarDropdown: ({ value, onChange, min, max, timeIntervalMinutes, utc, }: EndpointCalendarDropdownProps) => import("react/jsx-runtime").JSX.Element;
+export default EndpointCalendarDropdown;

package/dist/SuperDatePicker/components/EndpointCalendarDropdown.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import Calendar from "../../Calendar";
+import { StyledContent } from "../../core";
+import { momentToCalendarDate } from "../SuperDatePicker.lib";
+import { EndpointPopoverContent } from "../SuperDatePicker.styled";
+const EndpointCalendarDropdown = ({ value, onChange, min, max, timeIntervalMinutes, utc, }) => {
+    return (_jsx(StyledContent, { maxDropdownHeight: "fit-content", children: _jsx(EndpointPopoverContent, { children: _jsx(Calendar, { value: momentToCalendarDate(value, utc), onChange: onChange, includeTime: true, clearable: false, min: min, max: max, timeIntervalMinutes: timeIntervalMinutes, timeZoneLabel: utc ? "UTC" : "Local" }) }) }));
+};
+export default EndpointCalendarDropdown;

package/dist/SuperDatePicker/components/EndpointDateInput.d.ts

@@ -0,0 +1,16 @@
+import type { HTMLAttributes } from "react";
+import type { SuperDatePickerProps } from "../SuperDatePicker.types";
+declare const EndpointDateInput: import("react").ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "onChange"> & {
+    active: boolean;
+    ariaLabel: string;
+    value?: string | null;
+    onChange: (value?: string | null) => void;
+    onOpen: () => void;
+    format: NonNullable<SuperDatePickerProps["format"]>;
+    size: NonNullable<SuperDatePickerProps["size"]>;
+    disabled: boolean;
+    utc: boolean;
+    min?: Date;
+    max?: Date;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export default EndpointDateInput;

package/dist/SuperDatePicker/components/EndpointDateInput.js

@@ -0,0 +1,26 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import DateInput from "../../DateInput";
+import { EndpointInputTarget } from "../SuperDatePicker.styled";
+const EndpointDateInput = forwardRef((_a, ref) => {
+    var { active, ariaLabel, value, onChange, onOpen, format, size, disabled, utc, min, max } = _a, targetProps = __rest(_a, ["active", "ariaLabel", "value", "onChange", "onOpen", "format", "size", "disabled", "utc", "min", "max"]);
+    return (_jsx(EndpointInputTarget, Object.assign({}, targetProps, { ref: ref, size: size, "data-active": active, onPointerDownCapture: (event) => {
+            var _a;
+            (_a = targetProps.onPointerDownCapture) === null || _a === void 0 ? void 0 : _a.call(targetProps, event);
+            if (!disabled)
+                onOpen();
+        }, children: _jsx(DateInput, { "aria-label": ariaLabel, value: value, onChange: onChange, format: format, size: size, variant: "text", arrow: false, clearable: false, disabled: disabled, utc: utc, min: min, max: max }) })));
+});
+EndpointDateInput.displayName = "EndpointDateInput";
+export default EndpointDateInput;