@opentiny/vue-renderless 3.6.8 → 3.8.0

package/action-sheet/index.js

@@ -22,7 +22,7 @@ const setSheetStyle = ({ state, props }) => () => {
 const initScrollMenu = ({ state, nextTick, refs, BScroll }) => () => {
   nextTick(() => {
     const { scrollMenu } = refs;
-    if (!state.scroll) {
+    if (state.scroll) {
       state.scroll = new BScroll(scrollMenu, {
         probeType: 3,
         tap: "tap"
@@ -51,9 +51,36 @@ const menuHandle = ({ emit, state }) => (item) => {
   emit("update:modelValue", item.id);
   emit("click", item);
 };
+const close = ({ emit, vm }) => () => {
+  vm.$refs.drawer.close();
+  emit("close", false);
+};
+const hide = (emit) => () => {
+  emit("hide", false);
+  emit("update:visible", false);
+};
+const selectOption = ({ emit, props }) => (option) => {
+  const { valueField } = props;
+  emit("update:visible", false);
+  emit("update:modelValue", option[valueField]);
+  emit("click", option);
+};
+const confirm = ({ emit, state }) => () => {
+  emit("confirm", state);
+  emit("update:visible", false);
+};
+const actionSelectOption = ({ emit }) => (option, index) => {
+  emit("update:visible", false);
+  emit("click", option, index);
+};
 export {
+  actionSelectOption,
+  close,
+  confirm,
+  hide,
   initScrollMenu,
   menuHandle,
+  selectOption,
   setSheetStyle,
   visibleHandle,
   watchVisible

package/action-sheet/vue.js

@@ -1,7 +1,7 @@
 import "../chunk-PKUHTIDK.js";
-import { setSheetStyle, initScrollMenu, visibleHandle, watchVisible, menuHandle } from "./index";
-const api = ["state", "setSheetStyle", "initScrollMenu", "visibleHandle", "menuHandle"];
-const renderless = (props, { reactive, watch }, { emit, nextTick, refs }, { BScroll }) => {
+import { setSheetStyle, initScrollMenu, visibleHandle, watchVisible, menuHandle, close, selectOption, confirm, actionSelectOption, hide } from "./index";
+const api = ["state", "setSheetStyle", "initScrollMenu", "visibleHandle", "menuHandle", "close", "selectOption", "confirm", "actionSelectOption", "hide"];
+const renderless = (props, { reactive, watch }, { emit, nextTick, refs, vm }, { BScroll }) => {
   const api2 = {};
   const state = reactive({
     toggle: false,
@@ -20,13 +20,19 @@ const renderless = (props, { reactive, watch }, { emit, nextTick, refs }, { BScr
       api2.watchVisible(value);
     }
   );
+  watch(() => props.visible, api2.watchVisible, { immediate: true });
   Object.assign(api2, {
     state,
     setSheetStyle: setSheetStyle({ state, props }),
     initScrollMenu: initScrollMenu({ state, nextTick, refs, BScroll }),
     visibleHandle: visibleHandle({ emit, state }),
     watchVisible: watchVisible({ emit, props, state }),
-    menuHandle: menuHandle({ state, emit })
+    menuHandle: menuHandle({ state, emit }),
+    confirm: confirm({ state, emit }),
+    selectOption: selectOption({ emit, props }),
+    actionSelectOption: actionSelectOption({ emit }),
+    close: close({ emit, vm }),
+    hide: hide(emit)
   });
   return api2;
 };

package/alert/index.js

@@ -3,10 +3,32 @@ const close = ({ emit, state }) => () => {
   state.show = false;
   emit("close");
 };
-const computedGetIcon = ({ constants, props }) => () => props.icon || constants.ICON_MAP[props.type];
+const computedGetIcon = ({ constants, props, designConfig }) => () => {
+  var _a;
+  const designIcon = (_a = designConfig == null ? void 0 : designConfig.icons) == null ? void 0 : _a[props.type];
+  return props.icon || designIcon || constants.ICON_MAP[props.type];
+};
 const computedGetTitle = ({ constants, t, props }) => () => props.title || t(constants.TITLE_MAP[props.type]);
+const handleHeaderClick = ({ state, props, vm }) => () => {
+  if (props.showFoldable) {
+    state.contentVisible = !state.contentVisible;
+  }
+  if (vm.$refs.ContentDescribe) {
+    state.contentDescribeHeight = vm.$refs.ContentDescribe.scrollHeight;
+    if (state.contentDescribeHeight > state.contentMaxHeight) {
+      state.scrollStatus = true;
+    }
+  }
+  if (vm.$refs.ContentDefault) {
+    state.contentDefaultHeight = vm.$refs.ContentDefault.scrollHeight;
+    if (state.contentDefaultHeight > state.contentMaxHeight) {
+      state.scrollStatus = true;
+    }
+  }
+};
 export {
   close,
   computedGetIcon,
-  computedGetTitle
+  computedGetTitle,
+  handleHeaderClick
 };

package/alert/vue.js

@@ -1,20 +1,24 @@
 import "../chunk-PKUHTIDK.js";
-import { close, computedGetIcon, computedGetTitle } from "./index";
-const api = ["close", "state"];
-const renderless = (props, { computed, reactive }, { t, emit, constants }) => {
-  const api2 = {
-    computedGetIcon: computedGetIcon({ constants, props }),
-    computedGetTitle: computedGetTitle({ constants, props, t })
-  };
+import { close, computedGetIcon, computedGetTitle, handleHeaderClick } from "./index";
+const api = ["close", "state", "handleHeaderClick"];
+const renderless = (props, { computed, reactive }, { t, emit, constants, vm, designConfig }) => {
   const state = reactive({
     show: true,
     getIcon: computed(() => api2.computedGetIcon()),
-    getTitle: computed(() => api2.computedGetTitle())
+    getTitle: computed(() => api2.computedGetTitle()),
+    contentVisible: false,
+    contentDescribeHeight: 0,
+    contentDefaultHeight: 0,
+    contentMaxHeight: constants.CONTENT_MAXHEUGHT,
+    scrollStatus: false
   });
-  Object.assign(api2, {
+  const api2 = {
     state,
-    close: close({ state, emit })
-  });
+    computedGetIcon: computedGetIcon({ constants, props, designConfig }),
+    computedGetTitle: computedGetTitle({ constants, props, t }),
+    close: close({ state, emit }),
+    handleHeaderClick: handleHeaderClick({ state, props, vm })
+  };
   return api2;
 };
 export {

package/amount/index.js

@@ -2,10 +2,10 @@ import {
   __spreadProps,
   __spreadValues
 } from "../chunk-PKUHTIDK.js";
-import { on, off } from "@opentiny/vue-renderless/common/deps/dom";
-import { formatNumber } from "@opentiny/vue-renderless/common/decimal";
-import { getMiniDecimal, equalsDecimal } from "@opentiny/vue-renderless/common/bigInt";
-import { isNumber } from "@opentiny/vue-renderless/common/type";
+import { on, off } from "../common/deps/dom";
+import { formatNumber } from "../common/decimal";
+import { getMiniDecimal, equalsDecimal } from "../common/bigInt";
+import { isNumber } from "../common/type";
 const initService = (service) => {
   const { utils = {} } = service || {};
   const noopFn = () => null;

package/anchor/index.js

@@ -1,5 +1,5 @@
 import "../chunk-PKUHTIDK.js";
-import { addClass, removeClass } from "@opentiny/vue-renderless/common/deps/dom";
+import { addClass, removeClass } from "../common/deps/dom";
 const setFixAnchor = ({ vm }) => {
   const { fixRef } = vm.$refs;
   if (fixRef) {

package/autocomplete/vue.js

@@ -1,7 +1,7 @@
 import "../chunk-PKUHTIDK.js";
-import debounce from "@opentiny/vue-renderless/common/deps/debounce";
-import userPopper from "@opentiny/vue-renderless/common/deps/vue-popper";
-import { guid } from "@opentiny/vue-renderless/common/string";
+import debounce from "../common/deps/debounce";
+import userPopper from "../common/deps/vue-popper";
+import { guid } from "../common/string";
 import {
   computedVisible,
   watchVisible,

package/autonavi-map/index.js

@@ -1,5 +1,5 @@
 import "../chunk-PKUHTIDK.js";
-import { getAmap } from "@opentiny/vue-renderless/chart-core/deps/utils";
+import { getAmap } from "../chart-core/deps/utils";
 const amap = (columns, rows, settings, extra) => {
   const { key, v, amap: amap2, useOuterMap, url } = settings;
   const { _once } = extra;

package/badge/vue.js

@@ -1,19 +1,19 @@
 import "../chunk-PKUHTIDK.js";
 import { computedContent, computedValueRef } from "./index";
-import { xss } from "@opentiny/vue-renderless/common/xss";
+import { xss } from "../common/xss";
 const api = ["state"];
 const renderless = (props, { computed, reactive }) => {
-  const api2 = {
-    computedValueRef: computedValueRef({ props })
-  };
   const state = reactive({
     isOverstep: false,
     valueRef: computed(() => api2.computedValueRef()),
     content: computed(() => api2.computedContent()),
     href: computed(() => xss.filterUrl(props.href))
   });
-  api2.state = state;
-  api2.computedContent = computedContent({ props, state });
+  const api2 = {
+    state,
+    computedValueRef: computedValueRef({ props }),
+    computedContent: computedContent({ props, state })
+  };
   return api2;
 };
 export {

package/baidu-map/index.js

@@ -1,5 +1,5 @@
 import "../chunk-PKUHTIDK.js";
-import { getBmap } from "@opentiny/vue-renderless/chart-core/deps/utils";
+import { getBmap } from "../chart-core/deps/utils";
 const bmap = (columns, rows, settings, extra) => {
   const { key, v, bmap: bmap2, useOuterMap, url } = settings;
   const { _once } = extra;

package/bulletin-board/index.js

@@ -1,5 +1,5 @@
 import "../chunk-PKUHTIDK.js";
-import { xss } from "@opentiny/vue-renderless/common/xss.js";
+import { xss } from "../common/xss.js";
 const getRoute = (route) => `/${route || ""}`.replace(/^\/+/, "/");
 const computedDataList = ({ props, state }) => () => {
   const list = props.data[Number(state.actName) - 1] || [];

package/calendar/index.js

@@ -1,6 +1,6 @@
 import "../chunk-PKUHTIDK.js";
-import { isLeapYear } from "@opentiny/vue-renderless/common/date";
-import { copyArray } from "@opentiny/vue-renderless/common/object";
+import { isLeapYear } from "../common/date";
+import { copyArray } from "../common/object";
 const getDays = (year, month) => [31, isLeapYear(year) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1];
 const getWeek = (year, month, day) => (/* @__PURE__ */ new Date(`${year}/${month}/${day}`)).getDay();
 const lastMonth = (year, month) => {

package/calendar-bar/index.js

@@ -0,0 +1,268 @@
+import "../chunk-PKUHTIDK.js";
+const normalConfig = (config, state) => {
+  let { weekFirst, disabled, holiday, workday, mark } = config || {};
+  const minWeekFirst = 0;
+  const maxWeekFirst = state.dayOfWeek - 1;
+  weekFirst = typeof weekFirst === "number" && weekFirst >= minWeekFirst && weekFirst <= maxWeekFirst ? Math.round(weekFirst) : minWeekFirst;
+  disabled = typeof disabled === "function" ? disabled : () => false;
+  holiday = typeof holiday === "function" ? holiday : () => true;
+  workday = typeof workday === "function" ? workday : () => true;
+  mark = typeof mark === "function" ? mark : () => "";
+  return { weekFirst, disabled, holiday, workday, mark };
+};
+const normalDate = (date) => {
+  date = !date ? /* @__PURE__ */ new Date() : !(date instanceof Date) ? new Date(date) : date;
+  date = date.toString() === "Invalid Date" ? /* @__PURE__ */ new Date() : date;
+  return date;
+};
+const splitDate = (date) => {
+  const today = /* @__PURE__ */ new Date();
+  const todayFullYear = today.getFullYear();
+  const todayMonth = today.getMonth() + 1;
+  const todayDate = today.getDate();
+  const currentFullYear = date.getFullYear();
+  const currentMonth = date.getMonth() + 1;
+  const currentDate = date.getDate();
+  return { todayFullYear, todayMonth, todayDate, currentFullYear, currentMonth, currentDate };
+};
+const getBuildDay = (args) => (year, month, date) => {
+  const { pad0: pad02, isCurrent, currentFullYear, currentMonth, holiday, workday, mark } = args;
+  const { currentDate, isToday, disabled, dayOfWeek } = args;
+  const dateStr = `${year}-${pad02(month)}-${pad02(date)}`;
+  const d = new Date(dateStr);
+  const isCurMon = isCurrent(year, month);
+  const isSat = d.getDay() === dayOfWeek - 1;
+  const isSun = d.getDay() === 0;
+  let isWorkday, isHoliday;
+  if (year === currentFullYear && month === currentMonth) {
+    if (isSat || isSun) {
+      isHoliday = holiday(d);
+      isWorkday = !isHoliday;
+    } else {
+      isWorkday = workday(d);
+      isHoliday = !isWorkday;
+    }
+  }
+  const markMsg = mark(d);
+  const marked = !!markMsg;
+  const day = { dateStr, marked, markMsg, isWorkday, isHoliday, isSat, isSun, isCurMon };
+  day.isCur = isCurMon && date === currentDate;
+  day.isToday = isToday(year, month, date);
+  day.disabled = disabled(d);
+  day.dateArr = [year, month, date];
+  return day;
+};
+const getPadCalendarDays = ({ calendarDays, buildDay }) => (flag, count, cur) => {
+  const sign = flag === "s" ? -1 : 1;
+  Array.from({ length: count }).map((v, i) => {
+    const d = new Date(cur.getTime() + (i + 1) * sign * 864e5);
+    const year = d.getFullYear();
+    const month = d.getMonth() + 1;
+    const date = d.getDate();
+    calendarDays[flag === "s" ? "unshift" : "push"](buildDay(year, month, date));
+  });
+};
+const equalArr = (arr1, arr2) => Array.isArray(arr1) && Array.isArray(arr2) && arr1.join(",") === arr2.join(",");
+const setDayRow = ({ calendarDays, state }) => calendarDays.map((day, i) => day.row = Math.floor(i / state.dayOfWeek));
+const pad0 = (str, n = 2) => String(str).padStart(n, "0");
+const getCalendarDays = (state) => (date, config) => {
+  date = normalDate(date);
+  let { weekFirst, disabled, holiday, workday, mark } = normalConfig(config, state);
+  const { todayFullYear, todayMonth, todayDate, currentFullYear, currentMonth, currentDate } = splitDate(date);
+  const isToday = (year, month, date2) => year === todayFullYear && month === todayMonth && date2 === todayDate;
+  const isCurrent = (year, month) => year === currentFullYear && month === currentMonth;
+  const february = currentFullYear % 4 === 0 && currentFullYear % 100 !== 0 || currentFullYear % 400 === 0 ? 29 : 28;
+  const monthDays = [-1, 31, february, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  const f = (arr) => arr[0];
+  const l = (arr) => arr[arr.length - 1];
+  const { dayOfWeek } = state;
+  const args = { pad0, isCurrent, currentFullYear, currentMonth, holiday, workday, mark };
+  Object.assign(args, { currentDate, isToday, disabled, dayOfWeek });
+  const buildDay = getBuildDay(args);
+  const calendarDays = Array.from({ length: monthDays[currentMonth] }).map(
+    (v, i) => buildDay(currentFullYear, currentMonth, i + 1)
+  );
+  const weekDays = Array.from({ length: dayOfWeek }).map((v, i) => (weekFirst + i) % dayOfWeek);
+  const monthDaysFirst = new Date(f(calendarDays).dateStr).getDay();
+  const monthDaysLast = new Date(l(calendarDays).dateStr).getDay();
+  const padCalendarDays = getPadCalendarDays({ calendarDays, buildDay });
+  let count = monthDaysFirst !== f(weekDays) ? weekDays.indexOf(monthDaysFirst) : dayOfWeek;
+  padCalendarDays("s", count, new Date(f(calendarDays).dateStr));
+  count = monthDaysLast !== l(weekDays) ? dayOfWeek - 1 - weekDays.indexOf(monthDaysLast) : dayOfWeek;
+  padCalendarDays("e", count, new Date(l(calendarDays).dateStr));
+  setDayRow({ calendarDays, state });
+  if (!equalArr(state.weekDays, weekDays)) {
+    state.weekDays = weekDays;
+  }
+  state.calendarDays = calendarDays;
+  state.currentYear = `${currentFullYear}`;
+  state.currentMonth = `${currentMonth}`;
+  state.currentDate = `${currentDate}`;
+  state.cascaderCurrent = [currentFullYear, currentMonth];
+};
+const setStackRows = (state) => {
+  const { calendarDays } = state;
+  if (Array.isArray(calendarDays) && calendarDays.length) {
+    const currentDay = calendarDays.find((day) => day.isCur);
+    const allRows = [...new Set(calendarDays.map((day) => day.row))];
+    const index = allRows.indexOf(currentDay.row);
+    const stackRows = allRows.slice(index + 1).reverse().concat(allRows.slice(0, index));
+    state.stackRows = stackRows;
+  }
+};
+const computedCurrentRow = (state) => () => {
+  const { calendarDays } = state;
+  setStackRows(state);
+  if (Array.isArray(calendarDays) && calendarDays.length) {
+    const currentDay = calendarDays.find((day) => day.isCur);
+    if (currentDay) {
+      return currentDay.row;
+    }
+  }
+  return null;
+};
+const computedFilteredCalendarDays = (state) => () => {
+  const { calendarDays, currentRow, visibleRows } = state;
+  if (Array.isArray(calendarDays) && calendarDays.length && currentRow !== null) {
+    const rows = [...visibleRows, currentRow];
+    return calendarDays.filter((day) => ~rows.indexOf(day.row));
+  }
+  return [];
+};
+const clearVisibleRows = (state) => state.visibleRows = [];
+const fillVisibleRows = (state) => state.visibleRows = [...new Set((state.calendarDays || []).map((day) => day.row))];
+const handleDraggerClick = (state) => () => {
+  const { visibleRows } = state;
+  if (state.dragging)
+    return;
+  if (Array.isArray(visibleRows) && visibleRows.length) {
+    clearVisibleRows(state);
+  } else {
+    fillVisibleRows(state);
+  }
+};
+const handleClickDay = ({ api, emit, props }) => (day) => {
+  if (day.isCur || day.disabled)
+    return;
+  if (typeof day.dateStr === "string") {
+    api.getCalendarDays(day.dateStr, props.config);
+    emit("update:modelValue", day.dateStr);
+  }
+};
+const calcCalendarItemHeight = ({ state, vm }) => () => {
+  const calendarPanel = vm.$refs.calendarPanel;
+  if (calendarPanel && calendarPanel.childNodes instanceof NodeList && calendarPanel.childNodes.length > 1) {
+    setTimeout(() => {
+      state.itemHeight = calendarPanel.childNodes[1].offsetHeight;
+    });
+  }
+};
+const computedTotalRows = (state) => () => {
+  const { calendarDays, dayOfWeek } = state;
+  const total = Math.floor(calendarDays.length / dayOfWeek);
+  return total;
+};
+const dragStart = ({ state, vm, clientX, clientY }) => {
+  state.dragPosStart = state.dragPos = { clientX, clientY };
+  state.calendarPanelHeight = vm.$refs.calendarPanel.offsetHeight;
+  state.stackRowsCopy = state.stackRows.slice(0);
+};
+const dragEnd = ({ state, vm, clientY }) => {
+  const dy = clientY - state.dragPosStart.clientY;
+  state.dragPosStart = state.dragPos = {};
+  vm.$refs.calendarPanel.style.height = "auto";
+  if (dy > 0) {
+    fillVisibleRows(state);
+  } else if (dy < 0) {
+    clearVisibleRows(state);
+  }
+};
+const dragMove = ({ state, vm, clientX, clientY }) => {
+  const { dragPos: lastPos, itemHeight, totalRows, stackRowsCopy, currentRow } = state;
+  const minH = itemHeight;
+  const maxH = itemHeight * totalRows;
+  state.dragPos = { clientX, clientY };
+  state.calendarPanelHeight += clientY - lastPos.clientY;
+  let h = state.calendarPanelHeight;
+  h = h < minH ? minH : h > maxH ? maxH : h;
+  const showRows = Math.floor(h / itemHeight);
+  vm.$refs.calendarPanel.style.height = `${h}px`;
+  state.visibleRows = stackRowsCopy.slice(0).concat(currentRow).reverse().slice(0, showRows);
+};
+const handleDraggerMousedown = ({ api, state, vm }) => (e) => {
+  const { clientX, clientY } = e;
+  dragStart({ state, vm, clientX, clientY });
+  document.addEventListener("mouseup", api.handleMouseup);
+  document.addEventListener("mousemove", api.throttledHandleMousemove);
+};
+const handleMouseup = ({ api, state, vm }) => (e) => {
+  setTimeout(() => state.dragging = false);
+  document.removeEventListener("mouseup", api.handleMouseup);
+  document.removeEventListener("mousemove", api.throttledHandleMousemove);
+  dragEnd({ state, vm, clientY: e.clientY });
+};
+const handleMousemove = ({ state, vm }) => (e) => {
+  state.dragging = true;
+  const { clientX, clientY } = e;
+  dragMove({ state, vm, clientX, clientY });
+};
+const handleDraggerTouchstart = ({ state, vm }) => (e) => {
+  const { clientX, clientY } = e.changedTouches[0];
+  state.touching = true;
+  dragStart({ state, vm, clientX, clientY });
+};
+const handleDraggerTouchend = ({ state, vm }) => (e) => {
+  const { clientY } = e.changedTouches[0];
+  state.touching = false;
+  dragEnd({ state, vm, clientY });
+};
+const handleDraggerTouchmove = ({ state, vm }) => (e) => {
+  const { clientX, clientY } = e.changedTouches[0];
+  dragMove({ state, vm, clientX, clientY });
+};
+const setCascaderVisible = (state) => (value) => state.cascaderVisible = !!value;
+const handleCascaderChange = ({ api, emit, props, state }) => (val) => {
+  const { currentDate } = state;
+  let dateStr = `${val[0]}-${pad0(val[1])}-${pad0(currentDate)}`;
+  const numberCurrentDate = Number(currentDate);
+  const { currentFullYear: curYear, currentMonth: curMonth, currentDate: curDate } = splitDate(new Date(dateStr));
+  if (curYear !== val[0] || curMonth !== val[1] || curDate !== numberCurrentDate) {
+    dateStr = `${val[0]}-${pad0(val[1])}-01`;
+  }
+  api.getCalendarDays(dateStr, props.config);
+  emit("update:modelValue", dateStr);
+};
+const computeCascaderOptions = (t) => () => [
+  {
+    range: [2e3, 2050],
+    optionMethod: (i) => ({ id: i, label: t("ui.calendarBar.year").replace("%s", String(i)) })
+  },
+  { range: [1, 12], optionMethod: (i) => ({ id: i, label: t(`ui.calendarBar.month.${i}`) }) }
+];
+const i18nYearMonth = ({ state, t }) => () => {
+  const { currentYear, currentMonth } = state;
+  let template = t("ui.calendarBar.yearMonth");
+  const monthAbbr = t(`ui.calendarBar.monthAbbr.${currentMonth}`);
+  template = template.replace("%y", currentYear);
+  template = template.replace("%m", monthAbbr);
+  return template;
+};
+export {
+  calcCalendarItemHeight,
+  computeCascaderOptions,
+  computedCurrentRow,
+  computedFilteredCalendarDays,
+  computedTotalRows,
+  getCalendarDays,
+  handleCascaderChange,
+  handleClickDay,
+  handleDraggerClick,
+  handleDraggerMousedown,
+  handleDraggerTouchend,
+  handleDraggerTouchmove,
+  handleDraggerTouchstart,
+  handleMousemove,
+  handleMouseup,
+  i18nYearMonth,
+  setCascaderVisible
+};

package/calendar-bar/vue.js

@@ -0,0 +1,87 @@
+import "../chunk-PKUHTIDK.js";
+import {
+  getCalendarDays,
+  computedCurrentRow,
+  computedFilteredCalendarDays,
+  handleDraggerClick,
+  handleClickDay,
+  calcCalendarItemHeight,
+  computedTotalRows,
+  handleDraggerMousedown,
+  handleMouseup,
+  handleMousemove,
+  handleDraggerTouchstart,
+  handleDraggerTouchend,
+  handleDraggerTouchmove,
+  setCascaderVisible,
+  handleCascaderChange,
+  computeCascaderOptions,
+  i18nYearMonth
+} from "./index";
+import throttle from "../common/deps/throttle";
+const api = [
+  "state",
+  "handleDraggerClick",
+  "handleClickDay",
+  "handleDraggerMousedown",
+  "handleDraggerTouchstart",
+  "handleDraggerTouchend",
+  "throttledHandleDraggerTouchmove",
+  "setCascaderVisible",
+  "handleCascaderChange",
+  "i18nYearMonth"
+];
+const renderless = (props, { reactive, computed, onBeforeMount, onMounted }, { emit, vm, t }) => {
+  const state = reactive({
+    minSize2: "min-width: 3rem; min-height: 2rem",
+    minSize3: "min-width: 3rem; min-height: 3rem",
+    dayOfWeek: 7,
+    weekDays: [],
+    calendarDays: [],
+    currentYear: "",
+    currentMonth: "",
+    currentRow: computed(() => api2.computedCurrentRow()),
+    filteredCalendarDays: computed(() => api2.computedFilteredCalendarDays()),
+    visibleRows: [],
+    itemHeight: 0,
+    totalRows: computed(() => api2.computedTotalRows()),
+    dragging: false,
+    touching: false,
+    cascaderCurrent: [],
+    cascaderOptions: computed(() => api2.computeCascaderOptions()),
+    cascaderVisible: false
+  });
+  const api2 = {
+    state,
+    getCalendarDays: getCalendarDays(state),
+    computedCurrentRow: computedCurrentRow(state),
+    computedFilteredCalendarDays: computedFilteredCalendarDays(state),
+    handleDraggerClick: handleDraggerClick(state),
+    calcCalendarItemHeight: calcCalendarItemHeight({ state, vm }),
+    computedTotalRows: computedTotalRows(state),
+    throttledHandleMousemove: throttle(20, handleMousemove({ state, vm })),
+    handleDraggerTouchstart: handleDraggerTouchstart({ state, vm }),
+    handleDraggerTouchend: handleDraggerTouchend({ state, vm }),
+    throttledHandleDraggerTouchmove: throttle(20, handleDraggerTouchmove({ state, vm })),
+    setCascaderVisible: setCascaderVisible(state),
+    computeCascaderOptions: computeCascaderOptions(t),
+    i18nYearMonth: i18nYearMonth({ state, t })
+  };
+  Object.assign(api2, {
+    handleClickDay: handleClickDay({ api: api2, emit, props }),
+    handleDraggerMousedown: handleDraggerMousedown({ api: api2, state, vm }),
+    handleMouseup: handleMouseup({ api: api2, state, vm }),
+    handleCascaderChange: handleCascaderChange({ api: api2, emit, props, state })
+  });
+  onBeforeMount(() => {
+    api2.getCalendarDays(props.modelValue, props.config);
+  });
+  onMounted(() => {
+    api2.calcCalendarItemHeight();
+  });
+  return api2;
+};
+export {
+  api,
+  renderless
+};