@qsxy/element-plus-react 1.0.0-next.1

package/dist/TimePicker/TimeSpinnerPanel.js

@@ -0,0 +1,277 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/TimePicker/TimeSpinnerPanel.tsx
+var TimeSpinnerPanel_exports = {};
+__export(TimeSpinnerPanel_exports, {
+  default: () => TimeSpinnerPanel_default
+});
+module.exports = __toCommonJS(TimeSpinnerPanel_exports);
+var import_ahooks = require("ahooks");
+var import_classnames = __toESM(require("classnames"));
+var import_debounce = __toESM(require("lodash/debounce"));
+var import_react = __toESM(require("react"));
+var import_Scrollbar = require("../Scrollbar");
+var import_hooks = require("../hooks");
+var import_useTimePicker = require("./useTimePicker");
+var TimeSpinnerPanel = (0, import_react.memo)(
+  (0, import_react.forwardRef)((props, ref) => {
+    const { classPrefix = "time", showSeconds, value: valueProp, onChange } = props;
+    const { b, be, is } = (0, import_hooks.useClassNames)(classPrefix);
+    const spinnerDate = (0, import_react.useRef)(valueProp);
+    const isScrolling = (0, import_react.useRef)(false);
+    const listHoursRef = (0, import_react.useRef)(null);
+    const listMinutesRef = (0, import_react.useRef)(null);
+    const listSecondsRef = (0, import_react.useRef)(null);
+    const listMapRef = (0, import_react.useRef)(null);
+    const listRefsMap = (0, import_react.useMemo)(() => {
+      return {
+        hours: listHoursRef,
+        minutes: listMinutesRef,
+        seconds: listSecondsRef
+      };
+    }, []);
+    const spinnerItems = (0, import_react.useMemo)(() => {
+      const arr = ["hours", "minutes", "seconds"];
+      return showSeconds ? arr : arr.slice(0, 2);
+    }, [showSeconds]);
+    const hour = (0, import_react.useMemo)(() => {
+      return valueProp == null ? void 0 : valueProp.hour();
+    }, [valueProp]);
+    const minute = (0, import_react.useMemo)(() => {
+      return valueProp == null ? void 0 : valueProp.minute();
+    }, [valueProp]);
+    const second = (0, import_react.useMemo)(() => {
+      return valueProp == null ? void 0 : valueProp.second();
+    }, [valueProp]);
+    const timePartsMap = (0, import_react.useMemo)(() => {
+      return {
+        hours: hour,
+        minutes: minute,
+        seconds: second
+      };
+    }, [hour, minute, second]);
+    const getTimePartsMap = (0, import_react.useCallback)(() => {
+      return {
+        hours: spinnerDate.current.hour(),
+        minutes: spinnerDate.current.minute(),
+        seconds: spinnerDate.current.second()
+      };
+    }, []);
+    const { getHoursList, getMinutesList, getSecondsList } = (0, import_react.useMemo)(() => {
+      return (0, import_useTimePicker.getTimeLists)(props.disabledHours, props.disabledMinutes, props.disabledSeconds);
+    }, [props.disabledHours, props.disabledMinutes, props.disabledSeconds]);
+    const hoursList = (0, import_react.useMemo)(() => {
+      return getHoursList(props.role);
+    }, [getHoursList, props.role]);
+    const minutesList = (0, import_react.useMemo)(() => {
+      return getMinutesList(hour, props.role);
+    }, [getMinutesList, hour, props.role]);
+    const secondsList = (0, import_react.useMemo)(() => {
+      return getSecondsList(hour, minute, props.role);
+    }, [getSecondsList, hour, minute, props.role]);
+    const listMap = (0, import_react.useMemo)(() => {
+      return listMapRef.current = {
+        hours: hoursList,
+        minutes: minutesList,
+        seconds: secondsList
+      };
+    }, [hoursList, minutesList, secondsList]);
+    const typeItemHeight = (0, import_react.useCallback)(
+      (type) => {
+        const el = listRefsMap[type].current;
+        return el == null ? void 0 : el.querySelector("li").offsetHeight;
+      },
+      [listRefsMap]
+    );
+    const adjustSpinner = (0, import_react.useCallback)(
+      (type, value) => {
+        const el = listRefsMap[type].current;
+        if (el) {
+          el.querySelector(".el-scrollbar__wrap").scrollTop = Math.max(0, value * typeItemHeight(type));
+        }
+      },
+      [listRefsMap, typeItemHeight]
+    );
+    const modifyDateField = (0, import_react.useCallback)(
+      (type, value) => {
+        const list = listMapRef.current[type];
+        const isDisabled = list[value];
+        if (isDisabled) {
+          return;
+        }
+        switch (type) {
+          case "hours":
+            onChange == null ? void 0 : onChange(spinnerDate.current.hour(value), { defaultTime: true });
+            break;
+          case "minutes":
+            onChange == null ? void 0 : onChange(spinnerDate.current.minute(value), { defaultTime: true });
+            break;
+          case "seconds":
+            onChange == null ? void 0 : onChange(spinnerDate.current.second(value), { defaultTime: true });
+            break;
+        }
+      },
+      [spinnerDate, onChange]
+    );
+    const adjustCurrentSpinner = (0, import_react.useCallback)(
+      (type) => {
+        adjustSpinner(type, getTimePartsMap()[type]);
+      },
+      [adjustSpinner, getTimePartsMap]
+    );
+    const debouncedResetScroll = (0, import_debounce.default)(
+      (0, import_react.useCallback)(
+        (type) => {
+          isScrolling.current = false;
+          adjustCurrentSpinner(type);
+        },
+        [adjustCurrentSpinner]
+      ),
+      200
+    );
+    const adjustSpinners = (0, import_react.useCallback)(() => {
+      adjustCurrentSpinner("hours");
+      adjustCurrentSpinner("minutes");
+      adjustCurrentSpinner("seconds");
+    }, [adjustCurrentSpinner]);
+    const handleClick = (0, import_react.useCallback)(
+      (type, { value, disabled }) => {
+        if (!disabled) {
+          modifyDateField(type, value);
+          adjustSpinner(type, value);
+        }
+      },
+      [modifyDateField, adjustSpinner]
+    );
+    const scrollBarHeight = (0, import_react.useCallback)(
+      (type) => {
+        var _a;
+        return (_a = listRefsMap[type].current) == null ? void 0 : _a.offsetHeight;
+      },
+      [listRefsMap]
+    );
+    const handleScroll = (0, import_react.useCallback)(
+      (type) => {
+        var _a;
+        isScrolling.current = true;
+        const value = Math.min(
+          Math.round(
+            (((_a = listRefsMap[type].current) == null ? void 0 : _a.querySelector(".el-scrollbar__wrap").scrollTop) - (scrollBarHeight(type) * 0.5 - 10) / typeItemHeight(type) + 3) / typeItemHeight(type)
+          ),
+          type === "hours" ? 23 : 59
+        );
+        debouncedResetScroll(type);
+        modifyDateField(type, value);
+      },
+      [debouncedResetScroll, listRefsMap, modifyDateField, scrollBarHeight, typeItemHeight]
+    );
+    const bindFuntion = (0, import_react.useCallback)(
+      (type) => {
+        if (listRefsMap[type].current) {
+          listRefsMap[type].current.querySelector(".el-scrollbar__wrap").onscroll = () => {
+            handleScroll(type);
+          };
+        }
+      },
+      [handleScroll, listRefsMap]
+    );
+    const unbindFuntion = (0, import_react.useCallback)(
+      (type) => {
+        if (listRefsMap[type].current) {
+          listRefsMap[type].current.querySelector(".el-scrollbar__wrap").removeEventListener("scroll", () => {
+            handleScroll(type);
+          });
+        }
+      },
+      [handleScroll, listRefsMap]
+    );
+    const bindScrollEvent = (0, import_react.useCallback)(() => {
+      bindFuntion("hours");
+      bindFuntion("minutes");
+      bindFuntion("seconds");
+    }, [bindFuntion]);
+    const unbindScrollEvent = (0, import_react.useCallback)(() => {
+      unbindFuntion("hours");
+      unbindFuntion("minutes");
+      unbindFuntion("seconds");
+    }, [unbindFuntion]);
+    (0, import_react.useImperativeHandle)(ref, () => ({
+      adjustSpinners
+    }));
+    (0, import_ahooks.useMount)(() => {
+      bindScrollEvent();
+      adjustSpinners();
+      return unbindScrollEvent;
+    });
+    (0, import_react.useEffect)(() => {
+      spinnerDate.current = valueProp;
+      if (isScrolling.current) {
+        return;
+      }
+      if (valueProp == null ? void 0 : valueProp.isValid()) {
+        adjustSpinners();
+      }
+    }, [valueProp]);
+    return /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(be("panel", "content"), { "has-seconds": props.showSeconds }, props.className) }, /* @__PURE__ */ import_react.default.createElement("div", { className: (0, import_classnames.default)(b`spinner`, { "has-seconds": props.showSeconds }) }, spinnerItems.map((item) => {
+      return /* @__PURE__ */ import_react.default.createElement(
+        import_Scrollbar.Scrollbar,
+        {
+          key: item,
+          maxHeight: "inherit",
+          className: be("spinner", "wrapper"),
+          viewClass: be("spinner", "list"),
+          tag: "ul",
+          ref: (_ref) => {
+            var _a;
+            return listRefsMap[item].current = (_a = _ref == null ? void 0 : _ref.ref) == null ? void 0 : _a.current;
+          },
+          noresize: true,
+          onScroll: () => handleScroll(item),
+          onMouseMove: () => adjustCurrentSpinner(item)
+        },
+        listMap[item].map((disabled, key) => {
+          return /* @__PURE__ */ import_react.default.createElement(
+            "li",
+            {
+              className: (0, import_classnames.default)(be("spinner", "item"), is({ active: timePartsMap[item] === key, disabled })),
+              key,
+              onClick: () => handleClick(item, { disabled, value: key })
+            },
+            `${key < 10 ? 0 : ""}${key}`
+          );
+        })
+      );
+    })));
+  })
+);
+TimeSpinnerPanel.defaultProps = {
+  showSeconds: true
+};
+TimeSpinnerPanel.displayName = "TimeSpinnerPanel";
+var TimeSpinnerPanel_default = TimeSpinnerPanel;

package/dist/TimePicker/index.d.ts

@@ -0,0 +1,3 @@
+export { default as TimePicker } from './TimePicker';
+export { default as TimeSpinnerPanel } from './TimeSpinnerPanel';
+export type { TimePanelRef, TimePickerProps, TimePickerRef } from './typings';

package/dist/TimePicker/index.js

@@ -0,0 +1,42 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/TimePicker/index.ts
+var TimePicker_exports = {};
+__export(TimePicker_exports, {
+  TimePicker: () => import_TimePicker.default,
+  TimeSpinnerPanel: () => import_TimeSpinnerPanel.default
+});
+module.exports = __toCommonJS(TimePicker_exports);
+var import_TimePicker = __toESM(require("./TimePicker"));
+var import_TimeSpinnerPanel = __toESM(require("./TimeSpinnerPanel"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TimePicker,
+  TimeSpinnerPanel
+});

package/dist/TimePicker/typings.d.ts

@@ -0,0 +1,81 @@
+import { Dayjs } from 'dayjs';
+import { RefObject } from 'react';
+import { ValueRagne } from '../Calendar';
+import { DatePickerProps, DatePickerRangeProps } from '../DatePicker';
+import { InputRef } from '../Input';
+import { PopperOptionRef } from '../Popper';
+import { AnimationEventProps, BaseProps, NativeProps } from '../types/common';
+export type RoleType = 'start' | string;
+export type Compare = any;
+export type TimeType = 'hours' | 'minutes' | 'seconds';
+export type DisabledHours = (role?: RoleType, compare?: Compare) => number[];
+export type DisabledMinutes = (hour: number, role?: RoleType, compare?: Compare) => number[];
+export type DisabledSeconds = (hour: number, minute: number, role?: RoleType, compare?: Compare) => number[];
+export interface TimeList {
+    value: number;
+    disabled: boolean;
+}
+export interface ChangeParams {
+    month?: number;
+    defaultTime?: boolean;
+}
+export type TimePickerRef = {
+    inputInstance?: InputRef;
+    popperInstRef: PopperOptionRef;
+    getValue: () => string;
+    setValue: (value: string) => void;
+    setVisible: (value: boolean) => void;
+};
+export type TimePickerRangeRef = {
+    popperInstRef: PopperOptionRef;
+    getValue: () => [string, string];
+    setValue: (value: [string, string]) => void;
+    setVisible: (value: boolean) => void;
+};
+export type TimePickerProps = Omit<DatePickerProps, 'type' | 'instance'> & {
+    disabledHours?: DisabledHours;
+    disabledMinutes?: DisabledMinutes;
+    disabledSeconds?: DisabledSeconds;
+    name?: string;
+    value?: string;
+    defaultValue?: string;
+};
+export type TimePickerRangeProps = Omit<DatePickerRangeProps, 'type' | 'instance'> & {
+    disabledHours?: DisabledHours;
+    disabledMinutes?: DisabledMinutes;
+    disabledSeconds?: DisabledSeconds;
+    instance?: RefObject<TimePickerRangeRef>;
+};
+export interface TimeSpinnerProps extends BaseProps, NativeProps, AnimationEventProps {
+    value: Dayjs;
+    disabledHours?: DisabledHours;
+    disabledMinutes?: DisabledMinutes;
+    disabledSeconds?: DisabledSeconds;
+    showSeconds?: boolean;
+    role?: RoleType;
+    onChange: (value: Dayjs, params?: ChangeParams) => void;
+    setSelectionRange?: (start: number, end: number, pos?: 'min' | 'max') => void;
+}
+export interface TimePanelProps extends BaseProps, NativeProps, AnimationEventProps, TimeSpinnerProps {
+    visible?: boolean;
+    referenceElement: RefObject<HTMLElement> | (() => RefObject<HTMLElement>);
+    onDestroy: () => void;
+    onOk: () => void;
+}
+export interface TimeRangePanelProps extends BaseProps, NativeProps, AnimationEventProps, Omit<TimeSpinnerProps, 'value' | 'onChange'>, Omit<TimePickerRangeProps, 'instance' | 'value' | 'onChange'> {
+    value: ValueRagne;
+    onChange: (value: ValueRagne, params?: ChangeParams) => void;
+    visible: boolean;
+    onDestroy?: () => void;
+    onOk: () => void;
+}
+export interface TimePanelRef {
+    ref: HTMLDivElement;
+    adjustSpinners: () => void;
+}
+export interface TimeRangePanelRef {
+    ref: HTMLDivElement;
+}
+export interface SpinnerRef {
+    adjustSpinners: () => void;
+}

package/dist/TimePicker/typings.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/TimePicker/typings.ts
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);

package/dist/TimePicker/useTimePicker.d.ts

@@ -0,0 +1,11 @@
+import { Compare, DisabledHours, DisabledMinutes, DisabledSeconds, RoleType } from './typings';
+export declare const getTimeLists: (disabledHours: DisabledHours, disabledMinutes: DisabledMinutes, disabledSeconds: DisabledSeconds) => {
+    getHoursList: (role: RoleType, compare?: Compare) => boolean[];
+    getMinutesList: (hour: any, role: RoleType, compare?: Compare) => boolean[];
+    getSecondsList: (hour: any, minute: any, role: RoleType, compare?: Compare) => boolean[];
+};
+export declare const getAvailableArrs: (disabledHours: DisabledHours, disabledMinutes: DisabledMinutes, disabledSeconds: DisabledSeconds) => {
+    getAvailableHours: (role: RoleType, compare?: Compare) => number[];
+    getAvailableMinutes: (hour: number, role: RoleType, compare?: Compare) => number[];
+    getAvailableSeconds: (hour: number, minute: number, role: RoleType, compare?: Compare) => number[];
+};

package/dist/TimePicker/useTimePicker.js

@@ -0,0 +1,86 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/TimePicker/useTimePicker.ts
+var useTimePicker_exports = {};
+__export(useTimePicker_exports, {
+  getAvailableArrs: () => getAvailableArrs,
+  getTimeLists: () => getTimeLists
+});
+module.exports = __toCommonJS(useTimePicker_exports);
+var import_filter = __toESM(require("lodash/filter"));
+var makeList = (total, method, methodFunc) => {
+  const arr = [];
+  const disabledArr = method && methodFunc();
+  for (let i = 0; i < total; i++) {
+    arr[i] = disabledArr ? disabledArr.includes(i) : false;
+  }
+  return arr;
+};
+var makeAvailableArr = (list) => {
+  const res = list.map((_, index) => !_ ? index : _);
+  return (0, import_filter.default)(res, (_) => _ !== true);
+};
+var getTimeLists = (disabledHours, disabledMinutes, disabledSeconds) => {
+  const getHoursList = (role, compare) => {
+    return makeList(24, disabledHours, () => disabledHours(role, compare));
+  };
+  const getMinutesList = (hour, role, compare) => {
+    return makeList(60, disabledMinutes, () => disabledMinutes(hour, role, compare));
+  };
+  const getSecondsList = (hour, minute, role, compare) => {
+    return makeList(60, disabledSeconds, () => disabledSeconds(hour, minute, role, compare));
+  };
+  return {
+    getHoursList,
+    getMinutesList,
+    getSecondsList
+  };
+};
+var getAvailableArrs = (disabledHours, disabledMinutes, disabledSeconds) => {
+  const { getHoursList, getMinutesList, getSecondsList } = getTimeLists(disabledHours, disabledMinutes, disabledSeconds);
+  const getAvailableHours = (role, compare) => {
+    return makeAvailableArr(getHoursList(role, compare));
+  };
+  const getAvailableMinutes = (hour, role, compare) => {
+    return makeAvailableArr(getMinutesList(hour, role, compare));
+  };
+  const getAvailableSeconds = (hour, minute, role, compare) => {
+    return makeAvailableArr(getSecondsList(hour, minute, role, compare));
+  };
+  return {
+    getAvailableHours,
+    getAvailableMinutes,
+    getAvailableSeconds
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAvailableArrs,
+  getTimeLists
+});

package/dist/TimePicker/util.d.ts

@@ -0,0 +1,3 @@
+export declare const extractDateFormat: (format: string) => string;
+export declare const extractTimeFormat: (format: string) => string;
+export declare const makeRange: (start: number, end: number) => number[];

package/dist/TimePicker/util.js

@@ -0,0 +1,45 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/TimePicker/util.ts
+var util_exports = {};
+__export(util_exports, {
+  extractDateFormat: () => extractDateFormat,
+  extractTimeFormat: () => extractTimeFormat,
+  makeRange: () => makeRange
+});
+module.exports = __toCommonJS(util_exports);
+var extractDateFormat = (format) => {
+  return format.replace(/\W?m{1,2}|\W?ZZ/g, "").replace(/\W?h{1,2}|\W?s{1,3}|\W?a/gi, "").trim();
+};
+var extractTimeFormat = (format) => {
+  return format.replace(/\W?D{1,2}|\W?Do|\W?d{1,4}|\W?M{1,4}|\W?Y{2,4}/g, "").trim();
+};
+var makeRange = (start, end) => {
+  const result = [];
+  for (let i = start; i <= end; i++) {
+    result.push(i);
+  }
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractDateFormat,
+  extractTimeFormat,
+  makeRange
+});

package/dist/Tooltip/Tooltip.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { TooltipProps } from './typings';
+declare const Tooltip: FC<TooltipProps>;
+export default Tooltip;