@funcho/ui 1.0.0

package/dist/esm/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/time-picker/src/time-picker-com/basic-time-spinner.mjs

@@ -0,0 +1,412 @@
+import { defineComponent, inject, ref, computed, unref, onMounted, nextTick, watch, createElementBlock, openBlock, normalizeClass, createCommentVNode, Fragment, renderList, createBlock, withCtx, createTextVNode, toDisplayString, withDirectives, createElementVNode, createVNode } from 'vue';
+import { ElScrollbar } from '../../../scrollbar/index.mjs';
+import { ElIcon } from '../../../icon/index.mjs';
+import { ArrowUp as arrow_up_default, ArrowDown as arrow_down_default } from '../../../../../../../../@element-plus_icons-vue@2.3.2_vue@3.5.22_typescript@5.9.3_/node_modules/@element-plus/icons-vue/dist/index.mjs';
+import { PICKER_BASE_INJECTION_KEY, timeUnits, DEFAULT_FORMATS_TIME } from '../constants.mjs';
+import { buildTimeList } from '../utils.mjs';
+import { basicTimeSpinnerProps } from '../props/basic-time-spinner.mjs';
+import { getTimeLists } from '../composables/use-time-picker.mjs';
+import _export_sfc from '../../../../_virtual/plugin-vue_export-helper.mjs';
+import { vRepeatClick } from '../../../../directives/repeat-click/index.mjs';
+import { CHANGE_EVENT } from '../../../../constants/event.mjs';
+import { useNamespace } from '../../../../hooks/use-namespace/index.mjs';
+import { getStyle } from '../../../../utils/dom/style.mjs';
+import { isNumber } from '../../../../utils/types.mjs';
+import debounce from '../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/debounce.mjs';
+
+const _hoisted_1 = ["onClick"];
+const _hoisted_2 = ["onMouseenter"];
+const _sfc_main = defineComponent({
+  __name: "basic-time-spinner",
+  props: basicTimeSpinnerProps,
+  emits: [CHANGE_EVENT, "select-range", "set-option"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const pickerBase = inject(PICKER_BASE_INJECTION_KEY);
+    const { isRange, format } = pickerBase.props;
+    const emit = __emit;
+    const ns = useNamespace("time");
+    const { getHoursList, getMinutesList, getSecondsList } = getTimeLists(
+      props.disabledHours,
+      props.disabledMinutes,
+      props.disabledSeconds
+    );
+    let isScrolling = false;
+    const currentScrollbar = ref();
+    const listHoursRef = ref();
+    const listMinutesRef = ref();
+    const listSecondsRef = ref();
+    const listRefsMap = {
+      hours: listHoursRef,
+      minutes: listMinutesRef,
+      seconds: listSecondsRef
+    };
+    const spinnerItems = computed(() => {
+      return props.showSeconds ? timeUnits : timeUnits.slice(0, 2);
+    });
+    const timePartials = computed(() => {
+      const { spinnerDate } = props;
+      const hours = spinnerDate.hour();
+      const minutes = spinnerDate.minute();
+      const seconds = spinnerDate.second();
+      return { hours, minutes, seconds };
+    });
+    const timeList = computed(() => {
+      const { hours, minutes } = unref(timePartials);
+      const { role, spinnerDate } = props;
+      const compare = !isRange ? spinnerDate : void 0;
+      return {
+        hours: getHoursList(role, compare),
+        minutes: getMinutesList(hours, role, compare),
+        seconds: getSecondsList(hours, minutes, role, compare)
+      };
+    });
+    const arrowControlTimeList = computed(() => {
+      const { hours, minutes, seconds } = unref(timePartials);
+      return {
+        hours: buildTimeList(hours, 23),
+        minutes: buildTimeList(minutes, 59),
+        seconds: buildTimeList(seconds, 59)
+      };
+    });
+    const debouncedResetScroll = debounce((type) => {
+      isScrolling = false;
+      adjustCurrentSpinner(type);
+    }, 200);
+    const getAmPmFlag = (hour) => {
+      const shouldShowAmPm = !!props.amPmMode;
+      if (!shouldShowAmPm)
+        return "";
+      const isCapital = props.amPmMode === "A";
+      let content = hour < 12 ? " am" : " pm";
+      if (isCapital)
+        content = content.toUpperCase();
+      return content;
+    };
+    const emitSelectRange = (type) => {
+      let range = [0, 0];
+      const actualFormat = format || DEFAULT_FORMATS_TIME;
+      const hourIndex = actualFormat.indexOf("HH");
+      const minuteIndex = actualFormat.indexOf("mm");
+      const secondIndex = actualFormat.indexOf("ss");
+      switch (type) {
+        case "hours":
+          if (hourIndex !== -1) {
+            range = [hourIndex, hourIndex + 2];
+          }
+          break;
+        case "minutes":
+          if (minuteIndex !== -1) {
+            range = [minuteIndex, minuteIndex + 2];
+          }
+          break;
+        case "seconds":
+          if (secondIndex !== -1) {
+            range = [secondIndex, secondIndex + 2];
+          }
+          break;
+      }
+      const [left, right] = range;
+      emit("select-range", left, right);
+      currentScrollbar.value = type;
+    };
+    const adjustCurrentSpinner = (type) => {
+      adjustSpinner(type, unref(timePartials)[type]);
+    };
+    const adjustSpinners = () => {
+      adjustCurrentSpinner("hours");
+      adjustCurrentSpinner("minutes");
+      adjustCurrentSpinner("seconds");
+    };
+    const getScrollbarElement = (el) => el.querySelector(`.${ns.namespace.value}-scrollbar__wrap`);
+    const adjustSpinner = (type, value) => {
+      if (props.arrowControl)
+        return;
+      const scrollbar = unref(listRefsMap[type]);
+      if (scrollbar && scrollbar.$el) {
+        getScrollbarElement(scrollbar.$el).scrollTop = Math.max(
+          0,
+          value * typeItemHeight(type)
+        );
+      }
+    };
+    const typeItemHeight = (type) => {
+      const scrollbar = unref(listRefsMap[type]);
+      const listItem = scrollbar == null ? void 0 : scrollbar.$el.querySelector("li");
+      if (listItem) {
+        return Number.parseFloat(getStyle(listItem, "height")) || 0;
+      }
+      return 0;
+    };
+    const onIncrement = () => {
+      scrollDown(1);
+    };
+    const onDecrement = () => {
+      scrollDown(-1);
+    };
+    const scrollDown = (step) => {
+      if (!currentScrollbar.value) {
+        emitSelectRange("hours");
+      }
+      const label = currentScrollbar.value;
+      const now = unref(timePartials)[label];
+      const total = currentScrollbar.value === "hours" ? 24 : 60;
+      const next = findNextUnDisabled(label, now, step, total);
+      modifyDateField(label, next);
+      adjustSpinner(label, next);
+      nextTick(() => emitSelectRange(label));
+    };
+    const findNextUnDisabled = (type, now, step, total) => {
+      let next = (now + step + total) % total;
+      const list = unref(timeList)[type];
+      while (list[next] && next !== now) {
+        next = (next + step + total) % total;
+      }
+      return next;
+    };
+    const modifyDateField = (type, value) => {
+      const list = unref(timeList)[type];
+      const isDisabled = list[value];
+      if (isDisabled)
+        return;
+      const { hours, minutes, seconds } = unref(timePartials);
+      let changeTo;
+      switch (type) {
+        case "hours":
+          changeTo = props.spinnerDate.hour(value).minute(minutes).second(seconds);
+          break;
+        case "minutes":
+          changeTo = props.spinnerDate.hour(hours).minute(value).second(seconds);
+          break;
+        case "seconds":
+          changeTo = props.spinnerDate.hour(hours).minute(minutes).second(value);
+          break;
+      }
+      emit(CHANGE_EVENT, changeTo);
+    };
+    const handleClick = (type, { value, disabled }) => {
+      if (!disabled) {
+        modifyDateField(type, value);
+        emitSelectRange(type);
+        adjustSpinner(type, value);
+      }
+    };
+    const handleScroll = (type) => {
+      const scrollbar = unref(listRefsMap[type]);
+      if (!scrollbar)
+        return;
+      isScrolling = true;
+      debouncedResetScroll(type);
+      const value = Math.min(
+        Math.round(
+          (getScrollbarElement(scrollbar.$el).scrollTop - (scrollBarHeight(type) * 0.5 - 10) / typeItemHeight(type) + 3) / typeItemHeight(type)
+        ),
+        type === "hours" ? 23 : 59
+      );
+      modifyDateField(type, value);
+    };
+    const scrollBarHeight = (type) => {
+      return unref(listRefsMap[type]).$el.offsetHeight;
+    };
+    const bindScrollEvent = () => {
+      const bindFunction = (type) => {
+        const scrollbar = unref(listRefsMap[type]);
+        if (scrollbar && scrollbar.$el) {
+          getScrollbarElement(scrollbar.$el).onscroll = () => {
+            handleScroll(type);
+          };
+        }
+      };
+      bindFunction("hours");
+      bindFunction("minutes");
+      bindFunction("seconds");
+    };
+    onMounted(() => {
+      nextTick(() => {
+        !props.arrowControl && bindScrollEvent();
+        adjustSpinners();
+        if (props.role === "start")
+          emitSelectRange("hours");
+      });
+    });
+    const setRef = (scrollbar, type) => {
+      listRefsMap[type].value = scrollbar != null ? scrollbar : void 0;
+    };
+    emit("set-option", [`${props.role}_scrollDown`, scrollDown]);
+    emit("set-option", [`${props.role}_emitSelectRange`, emitSelectRange]);
+    watch(
+      () => props.spinnerDate,
+      () => {
+        if (isScrolling)
+          return;
+        adjustSpinners();
+      }
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(
+        "div",
+        {
+          class: normalizeClass([unref(ns).b("spinner"), { "has-seconds": _ctx.showSeconds }])
+        },
+        [
+          !_ctx.arrowControl ? (openBlock(true), createElementBlock(
+            Fragment,
+            { key: 0 },
+            renderList(spinnerItems.value, (item) => {
+              return openBlock(), createBlock(unref(ElScrollbar), {
+                key: item,
+                ref_for: true,
+                ref: (scrollbar) => setRef(scrollbar, item),
+                class: normalizeClass(unref(ns).be("spinner", "wrapper")),
+                "wrap-style": "max-height: inherit;",
+                "view-class": unref(ns).be("spinner", "list"),
+                noresize: "",
+                tag: "ul",
+                onMouseenter: ($event) => emitSelectRange(item),
+                onMousemove: ($event) => adjustCurrentSpinner(item)
+              }, {
+                default: withCtx(() => [
+                  (openBlock(true), createElementBlock(
+                    Fragment,
+                    null,
+                    renderList(timeList.value[item], (disabled, key) => {
+                      return openBlock(), createElementBlock("li", {
+                        key,
+                        class: normalizeClass([
+                          unref(ns).be("spinner", "item"),
+                          unref(ns).is("active", key === timePartials.value[item]),
+                          unref(ns).is("disabled", disabled)
+                        ]),
+                        onClick: ($event) => handleClick(item, { value: key, disabled })
+                      }, [
+                        item === "hours" ? (openBlock(), createElementBlock(
+                          Fragment,
+                          { key: 0 },
+                          [
+                            createTextVNode(
+                              toDisplayString(("0" + (_ctx.amPmMode ? key % 12 || 12 : key)).slice(-2)) + toDisplayString(getAmPmFlag(key)),
+                              1
+                            )
+                          ],
+                          64
+                        )) : (openBlock(), createElementBlock(
+                          Fragment,
+                          { key: 1 },
+                          [
+                            createTextVNode(
+                              toDisplayString(("0" + key).slice(-2)),
+                              1
+                            )
+                          ],
+                          64
+                        ))
+                      ], 10, _hoisted_1);
+                    }),
+                    128
+                  ))
+                ]),
+                _: 2
+              }, 1032, ["class", "view-class", "onMouseenter", "onMousemove"]);
+            }),
+            128
+          )) : createCommentVNode("v-if", true),
+          _ctx.arrowControl ? (openBlock(true), createElementBlock(
+            Fragment,
+            { key: 1 },
+            renderList(spinnerItems.value, (item) => {
+              return openBlock(), createElementBlock("div", {
+                key: item,
+                class: normalizeClass([unref(ns).be("spinner", "wrapper"), unref(ns).is("arrow")]),
+                onMouseenter: ($event) => emitSelectRange(item)
+              }, [
+                withDirectives((openBlock(), createBlock(unref(ElIcon), {
+                  class: normalizeClass(["arrow-up", unref(ns).be("spinner", "arrow")])
+                }, {
+                  default: withCtx(() => [
+                    createVNode(unref(arrow_up_default))
+                  ]),
+                  _: 1
+                }, 8, ["class"])), [
+                  [unref(vRepeatClick), onDecrement]
+                ]),
+                withDirectives((openBlock(), createBlock(unref(ElIcon), {
+                  class: normalizeClass(["arrow-down", unref(ns).be("spinner", "arrow")])
+                }, {
+                  default: withCtx(() => [
+                    createVNode(unref(arrow_down_default))
+                  ]),
+                  _: 1
+                }, 8, ["class"])), [
+                  [unref(vRepeatClick), onIncrement]
+                ]),
+                createElementVNode(
+                  "ul",
+                  {
+                    class: normalizeClass(unref(ns).be("spinner", "list"))
+                  },
+                  [
+                    (openBlock(true), createElementBlock(
+                      Fragment,
+                      null,
+                      renderList(arrowControlTimeList.value[item], (time, key) => {
+                        return openBlock(), createElementBlock(
+                          "li",
+                          {
+                            key,
+                            class: normalizeClass([
+                              unref(ns).be("spinner", "item"),
+                              unref(ns).is("active", time === timePartials.value[item]),
+                              unref(ns).is("disabled", timeList.value[item][time])
+                            ])
+                          },
+                          [
+                            unref(isNumber)(time) ? (openBlock(), createElementBlock(
+                              Fragment,
+                              { key: 0 },
+                              [
+                                item === "hours" ? (openBlock(), createElementBlock(
+                                  Fragment,
+                                  { key: 0 },
+                                  [
+                                    createTextVNode(
+                                      toDisplayString(("0" + (_ctx.amPmMode ? time % 12 || 12 : time)).slice(-2)) + toDisplayString(getAmPmFlag(time)),
+                                      1
+                                    )
+                                  ],
+                                  64
+                                )) : (openBlock(), createElementBlock(
+                                  Fragment,
+                                  { key: 1 },
+                                  [
+                                    createTextVNode(
+                                      toDisplayString(("0" + time).slice(-2)),
+                                      1
+                                    )
+                                  ],
+                                  64
+                                ))
+                              ],
+                              64
+                            )) : createCommentVNode("v-if", true)
+                          ],
+                          2
+                        );
+                      }),
+                      128
+                    ))
+                  ],
+                  2
+                )
+              ], 42, _hoisted_2);
+            }),
+            128
+          )) : createCommentVNode("v-if", true)
+        ],
+        2
+      );
+    };
+  }
+});
+var TimeSpinner = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/time-picker/src/time-picker-com/basic-time-spinner.vue"]]);
+
+export { TimeSpinner as default };

package/dist/esm/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/time-picker/src/time-picker-com/panel-time-pick.mjs

@@ -0,0 +1,209 @@
+import { defineComponent, inject, ref, computed, createBlock, openBlock, Transition, withCtx, createElementBlock, createCommentVNode, normalizeClass, unref, createElementVNode, createVNode, toDisplayString, nextTick } from 'vue';
+import dayjs from '../../../../../../../../../../_virtual/dayjs.min.mjs';
+import { PICKER_BASE_INJECTION_KEY } from '../constants.mjs';
+import { panelTimePickerProps } from '../props/panel-time-picker.mjs';
+import { useTimePanel } from '../composables/use-time-panel.mjs';
+import { useOldValue, buildAvailableTimeSlotGetter } from '../composables/use-time-picker.mjs';
+import TimeSpinner from './basic-time-spinner.mjs';
+import _export_sfc from '../../../../_virtual/plugin-vue_export-helper.mjs';
+import { useNamespace } from '../../../../hooks/use-namespace/index.mjs';
+import { useLocale } from '../../../../hooks/use-locale/index.mjs';
+import { isUndefined } from '../../../../utils/types.mjs';
+import { getEventCode } from '../../../../utils/dom/event.mjs';
+import { EVENT_CODE } from '../../../../constants/aria.mjs';
+
+const _sfc_main = defineComponent({
+  __name: "panel-time-pick",
+  props: panelTimePickerProps,
+  emits: ["pick", "select-range", "set-picker-option"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const pickerBase = inject(PICKER_BASE_INJECTION_KEY);
+    const {
+      arrowControl,
+      disabledHours,
+      disabledMinutes,
+      disabledSeconds,
+      defaultValue
+    } = pickerBase.props;
+    const { getAvailableHours, getAvailableMinutes, getAvailableSeconds } = buildAvailableTimeSlotGetter(disabledHours, disabledMinutes, disabledSeconds);
+    const ns = useNamespace("time");
+    const { t, lang } = useLocale();
+    const selectionRange = ref([0, 2]);
+    const oldValue = useOldValue(props);
+    const transitionName = computed(() => {
+      return isUndefined(props.actualVisible) ? `${ns.namespace.value}-zoom-in-top` : "";
+    });
+    const showSeconds = computed(() => {
+      return props.format.includes("ss");
+    });
+    const amPmMode = computed(() => {
+      if (props.format.includes("A"))
+        return "A";
+      if (props.format.includes("a"))
+        return "a";
+      return "";
+    });
+    const isValidValue = (_date) => {
+      const parsedDate = dayjs(_date).locale(lang.value);
+      const result = getRangeAvailableTime(parsedDate);
+      return parsedDate.isSame(result);
+    };
+    const handleCancel = () => {
+      const old = oldValue.value;
+      emit("pick", old, false);
+      nextTick(() => {
+        oldValue.value = old;
+      });
+    };
+    const handleConfirm = (visible = false, first = false) => {
+      if (first)
+        return;
+      emit("pick", props.parsedValue, visible);
+    };
+    const handleChange = (_date) => {
+      if (!props.visible) {
+        return;
+      }
+      const result = getRangeAvailableTime(_date).millisecond(0);
+      emit("pick", result, true);
+    };
+    const setSelectionRange = (start, end) => {
+      emit("select-range", start, end);
+      selectionRange.value = [start, end];
+    };
+    const changeSelectionRange = (step) => {
+      const actualFormat = props.format;
+      const hourIndex = actualFormat.indexOf("HH");
+      const minuteIndex = actualFormat.indexOf("mm");
+      const secondIndex = actualFormat.indexOf("ss");
+      const list = [];
+      const mapping = [];
+      if (hourIndex !== -1) {
+        list.push(hourIndex);
+        mapping.push("hours");
+      }
+      if (minuteIndex !== -1) {
+        list.push(minuteIndex);
+        mapping.push("minutes");
+      }
+      if (secondIndex !== -1 && showSeconds.value) {
+        list.push(secondIndex);
+        mapping.push("seconds");
+      }
+      const index = list.indexOf(selectionRange.value[0]);
+      const next = (index + step + list.length) % list.length;
+      timePickerOptions["start_emitSelectRange"](mapping[next]);
+    };
+    const handleKeydown = (event) => {
+      const code = getEventCode(event);
+      const { left, right, up, down } = EVENT_CODE;
+      if ([left, right].includes(code)) {
+        const step = code === left ? -1 : 1;
+        changeSelectionRange(step);
+        event.preventDefault();
+        return;
+      }
+      if ([up, down].includes(code)) {
+        const step = code === up ? -1 : 1;
+        timePickerOptions["start_scrollDown"](step);
+        event.preventDefault();
+        return;
+      }
+    };
+    const { timePickerOptions, onSetOption, getAvailableTime } = useTimePanel({
+      getAvailableHours,
+      getAvailableMinutes,
+      getAvailableSeconds
+    });
+    const getRangeAvailableTime = (date) => {
+      return getAvailableTime(date, props.datetimeRole || "", true);
+    };
+    const parseUserInput = (value) => {
+      if (!value)
+        return null;
+      return dayjs(value, props.format).locale(lang.value);
+    };
+    const getDefaultValue = () => {
+      return dayjs(defaultValue).locale(lang.value);
+    };
+    emit("set-picker-option", ["isValidValue", isValidValue]);
+    emit("set-picker-option", ["parseUserInput", parseUserInput]);
+    emit("set-picker-option", ["handleKeydownInput", handleKeydown]);
+    emit("set-picker-option", ["getRangeAvailableTime", getRangeAvailableTime]);
+    emit("set-picker-option", ["getDefaultValue", getDefaultValue]);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Transition, { name: transitionName.value }, {
+        default: withCtx(() => [
+          _ctx.actualVisible || _ctx.visible ? (openBlock(), createElementBlock(
+            "div",
+            {
+              key: 0,
+              class: normalizeClass(unref(ns).b("panel"))
+            },
+            [
+              createElementVNode(
+                "div",
+                {
+                  class: normalizeClass([unref(ns).be("panel", "content"), { "has-seconds": showSeconds.value }])
+                },
+                [
+                  createVNode(TimeSpinner, {
+                    ref: "spinner",
+                    role: _ctx.datetimeRole || "start",
+                    "arrow-control": unref(arrowControl),
+                    "show-seconds": showSeconds.value,
+                    "am-pm-mode": amPmMode.value,
+                    "spinner-date": _ctx.parsedValue,
+                    "disabled-hours": unref(disabledHours),
+                    "disabled-minutes": unref(disabledMinutes),
+                    "disabled-seconds": unref(disabledSeconds),
+                    onChange: handleChange,
+                    onSetOption: unref(onSetOption),
+                    onSelectRange: setSelectionRange
+                  }, null, 8, ["role", "arrow-control", "show-seconds", "am-pm-mode", "spinner-date", "disabled-hours", "disabled-minutes", "disabled-seconds", "onSetOption"])
+                ],
+                2
+              ),
+              createElementVNode(
+                "div",
+                {
+                  class: normalizeClass(unref(ns).be("panel", "footer"))
+                },
+                [
+                  createElementVNode(
+                    "button",
+                    {
+                      type: "button",
+                      class: normalizeClass([unref(ns).be("panel", "btn"), "cancel"]),
+                      onClick: handleCancel
+                    },
+                    toDisplayString(unref(t)("el.datepicker.cancel")),
+                    3
+                  ),
+                  createElementVNode(
+                    "button",
+                    {
+                      type: "button",
+                      class: normalizeClass([unref(ns).be("panel", "btn"), "confirm"]),
+                      onClick: _cache[0] || (_cache[0] = ($event) => handleConfirm())
+                    },
+                    toDisplayString(unref(t)("el.datepicker.confirm")),
+                    3
+                  )
+                ],
+                2
+              )
+            ],
+            2
+          )) : createCommentVNode("v-if", true)
+        ]),
+        _: 1
+      }, 8, ["name"]);
+    };
+  }
+});
+var TimePickPanel = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/time-picker/src/time-picker-com/panel-time-pick.vue"]]);
+
+export { TimePickPanel as default };

package/dist/esm/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/time-picker/src/utils.mjs

@@ -0,0 +1,68 @@
+import dayjs from '../../../../../../../../../_virtual/dayjs.min.mjs';
+import { isEmpty } from '../../../utils/types.mjs';
+import { isArray, isDate } from '../../../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/dist/shared.esm-bundler.mjs';
+
+const buildTimeList = (value, bound) => {
+  return [
+    value > 0 ? value - 1 : void 0,
+    value,
+    value < bound ? value + 1 : void 0
+  ];
+};
+const rangeArr = (n) => Array.from(Array.from({ length: n }).keys());
+const 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();
+};
+const 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();
+};
+const dateEquals = function(a, b) {
+  const aIsDate = isDate(a);
+  const bIsDate = isDate(b);
+  if (aIsDate && bIsDate) {
+    return a.getTime() === b.getTime();
+  }
+  if (!aIsDate && !bIsDate) {
+    return a === b;
+  }
+  return false;
+};
+const valueEquals = function(a, b) {
+  const aIsArray = isArray(a);
+  const bIsArray = isArray(b);
+  if (aIsArray && bIsArray) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    return a.every((item, index) => dateEquals(item, b[index]));
+  }
+  if (!aIsArray && !bIsArray) {
+    return dateEquals(a, b);
+  }
+  return false;
+};
+const parseDate = function(date, format, lang) {
+  const day = isEmpty(format) || format === "x" ? dayjs(date).locale(lang) : dayjs(date, format).locale(lang);
+  return day.isValid() ? day : void 0;
+};
+const formatter = function(date, format, lang) {
+  if (isEmpty(format))
+    return date;
+  if (format === "x")
+    return +date;
+  return dayjs(date).locale(lang).format(format);
+};
+const makeList = (total, method) => {
+  var _a;
+  const arr = [];
+  const disabledArr = method == null ? void 0 : method();
+  for (let i = 0; i < total; i++) {
+    arr.push((_a = disabledArr == null ? void 0 : disabledArr.includes(i)) != null ? _a : false);
+  }
+  return arr;
+};
+const dayOrDaysToDate = (dayOrDays) => {
+  return isArray(dayOrDays) ? dayOrDays.map((d) => d.toDate()) : dayOrDays.toDate();
+};
+
+export { buildTimeList, dateEquals, dayOrDaysToDate, extractDateFormat, extractTimeFormat, formatter, makeList, parseDate, rangeArr, valueEquals };