@hanwenbo/x-taro-ui 0.0.1

package/es/components/contextMenu/types.d.ts

@@ -0,0 +1,69 @@
+import type { ReactElement, ReactNode } from 'react';
+import type { SizeVariant } from '../../theme/types';
+import type { PopconfirmPlacement } from '../popconfirm/types';
+interface ContextMenuItemBase {
+    label: ReactNode;
+    icon?: ReactNode;
+    description?: ReactNode;
+    shortcut?: ReactNode;
+    suffix?: ReactNode;
+    badge?: ReactNode;
+    disabled?: boolean;
+    divider?: boolean;
+    variant?: 'default' | 'danger';
+    danger?: boolean;
+    children?: ContextMenuItemType[];
+    onClick?: () => void;
+}
+/** Canonical items use `id`; the original Taro `key` identifier remains supported. */
+export declare type ContextMenuItemType = ContextMenuItemBase & ({
+    id: string;
+    key?: string;
+} | {
+    id?: string;
+    key: string;
+});
+export declare type ContextMenuSelectHandler = ((item: ContextMenuItemType) => void) | ((key: string, item: ContextMenuItemType) => void);
+export interface ContextMenuProps {
+    items?: ContextMenuItemType[];
+    visible?: boolean;
+    defaultVisible?: boolean;
+    position?: {
+        x: number;
+        y: number;
+    } | null;
+    onClose?: () => void;
+    onSelect?: ContextMenuSelectHandler;
+    size?: SizeVariant;
+    disabled?: boolean;
+    closeOnSelect?: boolean;
+    collisionPadding?: number;
+    sideOffset?: number;
+    /** Original anchored Taro composition API. */
+    children?: ReactNode;
+    title?: ReactNode;
+    placement?: PopconfirmPlacement;
+    emptyText?: ReactNode;
+    onVisibleChange?: (visible: boolean) => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export interface ContextMenuTriggerProps {
+    children: ReactElement;
+    disabled?: boolean;
+    delayLongPress?: number;
+    onContextMenu?: (position: {
+        x: number;
+        y: number;
+    }) => void;
+    onLongPress?: (position: {
+        x: number;
+        y: number;
+    }) => void;
+    /** Compatibility escape hatch for explicit overflow-action buttons. */
+    onClick?: () => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/es/components/contextMenu/types.js

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

package/es/components/datePicker/datePicker.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { PickerActions } from '../picker';
+import type { DatePickerProps } from './types';
+export declare const DatePicker: React.ForwardRefExoticComponent<DatePickerProps & React.RefAttributes<PickerActions>>;
+export default DatePicker;
+//# sourceMappingURL=datePicker.d.ts.map

package/es/components/datePicker/datePicker.js

@@ -0,0 +1,375 @@
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import React, { useCallback, useMemo, useState } from 'react';
+import { Text, View } from '@tarojs/components';
+import { usePressable } from "../../patterns";
+import { getFormControlTokens, useTokens, withOpacity } from "../../theme";
+import { classNames } from "../../utils";
+import { resolveLocaleText } from "../../utils/locale";
+import { useConfigProvider } from "../configProvider";
+import { Icon } from "../icon";
+import { Picker } from "../picker";
+import { TILL_NOW_VALUE, buildResolvedDateColumns, dateValueFromPicker, formatDateValue, getDateValueArray, getPartsFromValue, parseDateString, resolveDatePickerPrecision } from "./shared";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+function renderNode(content, style) {
+  if (typeof content === 'string' || typeof content === 'number') {
+    return /*#__PURE__*/_jsx(Text, {
+      style: style,
+      children: content
+    });
+  }
+  return content;
+}
+function getNodeText(content) {
+  return typeof content === 'string' || typeof content === 'number' ? String(content) : '';
+}
+var DatePickerTrigger = function DatePickerTrigger(_ref) {
+  var _allowClearConfig$cle;
+  var value = _ref.value,
+    formattedValue = _ref.formattedValue,
+    placeholder = _ref.placeholder,
+    open = _ref.open,
+    disabled = _ref.disabled,
+    size = _ref.size,
+    variant = _ref.variant,
+    allowClear = _ref.allowClear,
+    clearLabel = _ref.clearLabel,
+    onClear = _ref.onClear,
+    actions = _ref.actions,
+    prefixCls = _ref.prefixCls,
+    className = _ref.className,
+    style = _ref.style;
+  var _useTokens = useTokens(),
+    colors = _useTokens.colors,
+    radius = _useTokens.radius,
+    motion = _useTokens.motion;
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    focused = _useState2[0],
+    setFocused = _useState2[1];
+  var tokens = getFormControlTokens(size);
+  var press = usePressable({
+    disabled: disabled,
+    onPress: actions.open,
+    scale: 0.995
+  });
+  var allowClearConfig = _typeof(allowClear) === 'object' ? allowClear : allowClear ? {} : null;
+  var showClear = Boolean(allowClearConfig && value && !disabled);
+  var accessibleText = value ? getNodeText(formattedValue) : getNodeText(placeholder);
+  return /*#__PURE__*/_jsxs(View, _objectSpread(_objectSpread({
+    className: classNames("".concat(prefixCls, "-date-picker"), "".concat(prefixCls, "-date-picker--").concat(size), "".concat(prefixCls, "-date-picker--").concat(variant), open && "".concat(prefixCls, "-date-picker--open"), disabled && "".concat(prefixCls, "-date-picker--disabled"), focused && "".concat(prefixCls, "-date-picker--focused"), className),
+    style: _objectSpread(_objectSpread({
+      display: 'flex',
+      flexDirection: 'row',
+      alignItems: 'center',
+      width: '100%',
+      minWidth: 0,
+      height: tokens.height,
+      boxSizing: 'border-box',
+      gap: tokens.gap,
+      paddingLeft: tokens.inlinePadding,
+      paddingRight: tokens.inlinePadding,
+      borderWidth: variant === 'filled' ? 0 : 1,
+      borderStyle: 'solid',
+      borderColor: open || focused ? colors.primary : colors.border,
+      borderRadius: radius.md,
+      backgroundColor: variant === 'filled' ? colors.muted : colors.background,
+      boxShadow: open || focused ? "0 0 0 1px ".concat(withOpacity(colors.ring, 0.18)) : 'none',
+      opacity: disabled ? 0.5 : 1,
+      cursor: disabled ? 'not-allowed' : 'pointer'
+    }, press.style), {}, {
+      transition: "".concat(press.style.transition, ", border-color ").concat(motion.durationsMs.emphasis, "ms ").concat(motion.easing.standard, ", box-shadow ").concat(motion.durationsMs.emphasis, "ms ").concat(motion.easing.standard, ", background-color ").concat(motion.durationsMs.emphasis, "ms ").concat(motion.easing.standard)
+    }, style),
+    role: "button",
+    ariaRole: "button",
+    ariaLabel: accessibleText || '日期选择',
+    tabIndex: disabled ? -1 : 0,
+    onFocus: function onFocus() {
+      return setFocused(true);
+    },
+    onBlur: function onBlur() {
+      return setFocused(false);
+    },
+    onKeyDown: function onKeyDown(event) {
+      var key = event.key;
+      if (key === 'Enter' || key === ' ') {
+        var _preventDefault, _ref2;
+        (_preventDefault = (_ref2 = event).preventDefault) === null || _preventDefault === void 0 || _preventDefault.call(_ref2);
+        actions.open();
+      }
+    }
+  }, press.handlers), {}, {
+    children: [/*#__PURE__*/_jsx(View, {
+      style: {
+        flex: 1,
+        minWidth: 0,
+        overflow: 'hidden'
+      },
+      children: renderNode(value ? formattedValue : placeholder, {
+        display: 'block',
+        overflow: 'hidden',
+        textOverflow: 'ellipsis',
+        whiteSpace: 'nowrap',
+        fontSize: tokens.textSize,
+        color: value ? colors.foreground : colors['muted-foreground']
+      })
+    }), /*#__PURE__*/_jsxs(View, {
+      style: {
+        display: 'flex',
+        flexDirection: 'row',
+        alignItems: 'center',
+        gap: 4,
+        flexShrink: 0
+      },
+      children: [showClear ? /*#__PURE__*/_jsx(View, {
+        className: "".concat(prefixCls, "-date-picker__clear"),
+        role: "button",
+        ariaRole: "button",
+        ariaLabel: clearLabel,
+        style: {
+          width: tokens.iconSize + 6,
+          height: tokens.iconSize + 6,
+          display: 'flex',
+          alignItems: 'center',
+          justifyContent: 'center'
+        },
+        onClick: function onClick(event) {
+          return onClear(event);
+        },
+        children: (_allowClearConfig$cle = allowClearConfig === null || allowClearConfig === void 0 ? void 0 : allowClearConfig.clearIcon) !== null && _allowClearConfig$cle !== void 0 ? _allowClearConfig$cle : /*#__PURE__*/_jsx(Icon, {
+          name: "X",
+          size: Math.max(12, tokens.iconSize - 2),
+          color: colors['muted-foreground'],
+          block: true
+        })
+      }) : null, /*#__PURE__*/_jsx(View, {
+        className: "".concat(prefixCls, "-date-picker__arrow"),
+        style: {
+          width: tokens.iconSize,
+          height: tokens.iconSize,
+          display: 'flex',
+          alignItems: 'center',
+          justifyContent: 'center',
+          transform: open ? 'rotate(180deg)' : 'rotate(0deg)',
+          transition: "transform ".concat(motion.durationsMs.emphasis, "ms ").concat(motion.easing.standard)
+        },
+        children: /*#__PURE__*/_jsx(Icon, {
+          name: "ChevronDown",
+          size: Math.max(12, tokens.iconSize - 2),
+          color: colors['muted-foreground'],
+          block: true
+        })
+      })]
+    })]
+  }));
+};
+function createDefaultRenderLabel(locale) {
+  return function (type, value) {
+    if (type === 'now') {
+      return resolveLocaleText(locale, 'datepicker.tillNow', '至今');
+    }
+    var suffixes = {
+      year: resolveLocaleText(locale, 'datepicker.year', '年'),
+      month: resolveLocaleText(locale, 'datepicker.month', '月'),
+      day: resolveLocaleText(locale, 'datepicker.day', '日'),
+      hour: resolveLocaleText(locale, 'datepicker.hour', '时'),
+      minute: resolveLocaleText(locale, 'datepicker.minute', '分'),
+      second: resolveLocaleText(locale, 'datepicker.second', '秒')
+    };
+    return "".concat(value).concat(locale.toLowerCase().startsWith('zh') ? '' : ' ').concat(suffixes[type]);
+  };
+}
+export var DatePicker = /*#__PURE__*/React.forwardRef(function (props, ref) {
+  var hasValueProp = Object.prototype.hasOwnProperty.call(props, 'value');
+  var hasVisibleProp = Object.prototype.hasOwnProperty.call(props, 'visible') || Object.prototype.hasOwnProperty.call(props, 'open');
+  var value = props.value,
+    _props$defaultValue = props.defaultValue,
+    defaultValue = _props$defaultValue === void 0 ? null : _props$defaultValue,
+    visible = props.visible,
+    open = props.open,
+    _props$defaultVisible = props.defaultVisible,
+    defaultVisible = _props$defaultVisible === void 0 ? false : _props$defaultVisible,
+    precision = props.precision,
+    _props$minDate = props.minDate,
+    minDate = _props$minDate === void 0 ? '2000-01-01 00:00:00' : _props$minDate,
+    min = props.min,
+    _props$maxDate = props.maxDate,
+    maxDate = _props$maxDate === void 0 ? '2035-12-31 23:59:59' : _props$maxDate,
+    max = props.max,
+    picker = props.picker,
+    _props$showTime = props.showTime,
+    showTime = _props$showTime === void 0 ? false : _props$showTime,
+    format = props.format,
+    placeholder = props.placeholder,
+    title = props.title,
+    size = props.size,
+    _props$variant = props.variant,
+    variant = _props$variant === void 0 ? 'outline' : _props$variant,
+    disabled = props.disabled,
+    confirmText = props.confirmText,
+    cancelText = props.cancelText,
+    onChange = props.onChange,
+    onSelect = props.onSelect,
+    onOpenChange = props.onOpenChange,
+    onConfirm = props.onConfirm,
+    onCancel = props.onCancel,
+    onClose = props.onClose,
+    _props$closeOnMaskCli = props.closeOnMaskClick,
+    closeOnMaskClick = _props$closeOnMaskCli === void 0 ? true : _props$closeOnMaskCli,
+    disabledDate = props.disabledDate,
+    disabledTime = props.disabledTime,
+    renderLabel = props.renderLabel,
+    filter = props.filter,
+    _props$allowClear = props.allowClear,
+    allowClear = _props$allowClear === void 0 ? false : _props$allowClear,
+    onClear = props.onClear,
+    _props$tillNow = props.tillNow,
+    tillNow = _props$tillNow === void 0 ? false : _props$tillNow,
+    _props$loading = props.loading,
+    loading = _props$loading === void 0 ? false : _props$loading,
+    loadingContent = props.loadingContent,
+    popupClassName = props.popupClassName,
+    popupStyle = props.popupStyle,
+    headerClassName = props.headerClassName,
+    headerStyle = props.headerStyle,
+    footerClassName = props.footerClassName,
+    contentStyle = props.contentStyle,
+    itemHeight = props.itemHeight,
+    height = props.height,
+    renderValue = props.renderValue,
+    _children = props.children,
+    className = props.className,
+    style = props.style;
+  var config = useConfigProvider();
+  var resolvedSize = size !== null && size !== void 0 ? size : config.size;
+  var isDisabled = Boolean(disabled || config.disabled);
+  var resolvedPrecision = resolveDatePickerPrecision(precision, picker, showTime);
+  var resolvedMin = min !== null && min !== void 0 ? min : minDate;
+  var resolvedMax = max !== null && max !== void 0 ? max : maxDate;
+  var minDateValue = useMemo(function () {
+    return parseDateString(resolvedMin);
+  }, [resolvedMin]);
+  var maxDateValue = useMemo(function () {
+    return parseDateString(resolvedMax);
+  }, [resolvedMax]);
+  var _useState3 = useState(defaultValue),
+    _useState4 = _slicedToArray(_useState3, 2),
+    internalValue = _useState4[0],
+    setInternalValue = _useState4[1];
+  var _useState5 = useState(defaultVisible),
+    _useState6 = _slicedToArray(_useState5, 2),
+    internalOpen = _useState6[0],
+    setInternalOpen = _useState6[1];
+  var selectedValue = hasValueProp ? value !== null && value !== void 0 ? value : null : internalValue;
+  var resolvedVisible = open !== null && open !== void 0 ? open : visible;
+  var triggerOpen = hasVisibleProp ? Boolean(resolvedVisible) : internalOpen;
+  var fallbackParts = useMemo(function () {
+    return getPartsFromValue(selectedValue, minDateValue, maxDateValue);
+  }, [maxDateValue, minDateValue, selectedValue]);
+  var pickerValue = useMemo(function () {
+    return selectedValue === TILL_NOW_VALUE ? [TILL_NOW_VALUE] : getDateValueArray(fallbackParts, resolvedPrecision);
+  }, [fallbackParts, resolvedPrecision, selectedValue]);
+  var unitLabel = useMemo(function () {
+    return renderLabel !== null && renderLabel !== void 0 ? renderLabel : createDefaultRenderLabel(config.locale);
+  }, [config.locale, renderLabel]);
+  var columns = useCallback(function (nextValue) {
+    return buildResolvedDateColumns(nextValue, fallbackParts, minDateValue, maxDateValue, resolvedPrecision, {
+      renderLabel: unitLabel,
+      filter: filter,
+      tillNow: tillNow,
+      disabledDate: disabledDate,
+      disabledTime: disabledTime
+    });
+  }, [disabledDate, disabledTime, fallbackParts, filter, maxDateValue, minDateValue, resolvedPrecision, tillNow, unitLabel]);
+  var displayValue = selectedValue === TILL_NOW_VALUE ? resolveLocaleText(config.locale, 'datepicker.tillNow', '至今') : formatDateValue(selectedValue, resolvedPrecision, format);
+  var resolvedPlaceholder = placeholder !== null && placeholder !== void 0 ? placeholder : resolveLocaleText(config.locale, 'datepicker.placeholder', '请选择日期');
+  var clearLabel = resolveLocaleText(config.locale, 'common.clear', '清除');
+  var toDateValue = useCallback(function (nextPickerValue) {
+    return dateValueFromPicker(nextPickerValue, fallbackParts, minDateValue, maxDateValue, resolvedPrecision);
+  }, [fallbackParts, maxDateValue, minDateValue, resolvedPrecision]);
+  var handleSelect = useCallback(function (nextPickerValue) {
+    return onSelect === null || onSelect === void 0 ? void 0 : onSelect(toDateValue(nextPickerValue));
+  }, [onSelect, toDateValue]);
+  var handleConfirm = useCallback(function (nextPickerValue) {
+    var nextValue = toDateValue(nextPickerValue);
+    if (!hasValueProp) setInternalValue(nextValue);
+    onConfirm === null || onConfirm === void 0 || onConfirm(nextValue);
+    onChange === null || onChange === void 0 || onChange(nextValue, nextValue === TILL_NOW_VALUE ? resolveLocaleText(config.locale, 'datepicker.tillNow', '至今') : formatDateValue(nextValue, resolvedPrecision, format));
+  }, [config.locale, format, hasValueProp, onChange, onConfirm, resolvedPrecision, toDateValue]);
+  var handleClear = useCallback(function (event) {
+    var _event$stopPropagatio;
+    event === null || event === void 0 || (_event$stopPropagatio = event.stopPropagation) === null || _event$stopPropagatio === void 0 || _event$stopPropagatio.call(event);
+    if (isDisabled) return;
+    if (!hasValueProp) setInternalValue(null);
+    onClear === null || onClear === void 0 || onClear();
+    onChange === null || onChange === void 0 || onChange(null, '');
+  }, [hasValueProp, isDisabled, onChange, onClear]);
+  var handleOpenChange = useCallback(function (nextOpen) {
+    setInternalOpen(nextOpen);
+    onOpenChange === null || onOpenChange === void 0 || onOpenChange(nextOpen);
+  }, [onOpenChange]);
+  var visibilityProps = hasVisibleProp ? {
+    visible: Boolean(resolvedVisible)
+  } : {};
+  return /*#__PURE__*/_jsx(Picker, _objectSpread(_objectSpread({
+    ref: ref,
+    columns: columns,
+    value: pickerValue,
+    defaultVisible: defaultVisible
+  }, visibilityProps), {}, {
+    title: title,
+    confirmText: confirmText,
+    cancelText: cancelText,
+    size: resolvedSize,
+    variant: variant,
+    disabled: isDisabled,
+    loading: loading,
+    loadingContent: loadingContent,
+    closeOnMaskClick: closeOnMaskClick,
+    onSelect: handleSelect,
+    onConfirm: handleConfirm,
+    onCancel: onCancel,
+    onClose: onClose,
+    onOpenChange: handleOpenChange,
+    popupClassName: popupClassName,
+    popupStyle: popupStyle,
+    headerClassName: headerClassName,
+    headerStyle: headerStyle,
+    footerClassName: footerClassName,
+    contentStyle: contentStyle,
+    itemHeight: itemHeight,
+    height: height,
+    children: function children(_items, actions) {
+      var _renderValue;
+      return _children ? _children(selectedValue, actions) : /*#__PURE__*/_jsx(DatePickerTrigger, {
+        value: selectedValue,
+        formattedValue: (_renderValue = renderValue === null || renderValue === void 0 ? void 0 : renderValue(selectedValue, displayValue)) !== null && _renderValue !== void 0 ? _renderValue : displayValue,
+        placeholder: resolvedPlaceholder,
+        open: triggerOpen,
+        disabled: isDisabled,
+        size: resolvedSize,
+        variant: variant,
+        allowClear: allowClear,
+        clearLabel: clearLabel,
+        onClear: handleClear,
+        actions: actions,
+        prefixCls: config.prefixCls,
+        className: className,
+        style: style
+      });
+    }
+  }));
+});
+DatePicker.displayName = 'DatePicker';
+export default DatePicker;

package/es/components/datePicker/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export { default as DatePicker } from './datePicker';
+export { default } from './datePicker';
+//# sourceMappingURL=index.d.ts.map

package/es/components/datePicker/index.js

@@ -0,0 +1,3 @@
+export * from "./types";
+export { default as DatePicker } from "./datePicker";
+export { default } from "./datePicker";

package/es/components/datePicker/shared.d.ts

@@ -0,0 +1,35 @@
+import type { PickerValue } from '../picker';
+import type { PickerViewOption } from '../pickerView/types';
+import type { DatePickerFilter, DatePickerFormat, DatePickerMode, DatePickerPrecision, DatePickerRenderLabel, DatePickerShowTime, DatePickerSupportedPrecision } from './types';
+export interface DateParts {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+}
+export declare const TILL_NOW_VALUE = "__TILL_NOW__";
+export declare function parseDateString(value?: string): Date;
+export declare function clampDate(date: Date, minDate: Date, maxDate: Date): Date;
+export declare function dateToParts(date: Date): DateParts;
+export declare function resolveDatePickerPrecision(precision?: DatePickerPrecision, picker?: DatePickerMode, showTime?: DatePickerShowTime): DatePickerSupportedPrecision;
+export declare function getPrecisionUnits(precision: DatePickerSupportedPrecision): DatePickerSupportedPrecision[];
+export declare function normalizeDateParts(desiredParts: Partial<DateParts>, minDate: Date, maxDate: Date): DateParts;
+export declare function formatDateParts(parts: DateParts, precision: DatePickerSupportedPrecision): string;
+export declare function getPartsFromValue(value: string | null | undefined, minDate: Date, maxDate: Date): DateParts;
+export declare function buildDateColumns(parts: DateParts, minDate: Date, maxDate: Date, precision: DatePickerSupportedPrecision): PickerViewOption[][];
+export declare function getDateValueArray(parts: DateParts, precision: DatePickerSupportedPrecision): Array<string | number>;
+export declare function mergeDateValueArray(values: Array<string | number>, currentParts: DateParts, precision: DatePickerSupportedPrecision): Partial<DateParts>;
+export declare function formatDateValue(value: string | null, precision: DatePickerSupportedPrecision, format?: DatePickerFormat): string;
+interface ResolvedDateColumnsOptions {
+    renderLabel: DatePickerRenderLabel;
+    filter?: DatePickerFilter;
+    tillNow?: boolean;
+    disabledDate?: (date: Date) => boolean;
+    disabledTime?: (date: Date) => boolean;
+}
+export declare function buildResolvedDateColumns(selected: PickerValue[], fallbackParts: DateParts, minDate: Date, maxDate: Date, precision: DatePickerSupportedPrecision, options: ResolvedDateColumnsOptions): PickerViewOption[][];
+export declare function dateValueFromPicker(values: PickerValue[], fallbackParts: DateParts, minDate: Date, maxDate: Date, precision: DatePickerSupportedPrecision): string;
+export {};
+//# sourceMappingURL=shared.d.ts.map