@opentinyvue/vue-renderless 3.21.0

package/chart-tree/index.js

@@ -0,0 +1,65 @@
+import "../chunk-G2ADBYYC.js";
+import { isObject } from "../chart-core/deps/utils";
+import { itemLabel, itemContent, SAAS_DEFAULT_COLORS } from "../chart-core/deps/constants";
+const getTreeLegend = (args) => {
+  const { dimension, rows } = args;
+  const result = rows.map((row) => row[dimension]);
+  return { data: result };
+};
+const getTreeTooltip = (args) => {
+  const { tooltipFormatter } = args;
+  return {
+    trigger: "item",
+    triggerOn: "mousemove",
+    formatter(item) {
+      if (tooltipFormatter) {
+        return tooltipFormatter.apply(null, arguments);
+      }
+      let template = [];
+      const { treeAncestors, value } = item;
+      let names = [];
+      treeAncestors.forEach((ancestor, idx) => {
+        idx && names.push(ancestor.name);
+      });
+      template.push(`${itemLabel(names.join("."))}`);
+      template.push(`${itemContent(value)}`);
+      return template.join("");
+    }
+  };
+};
+const getTreeSeries = (args) => {
+  const { dimension, metrics, rows, seriesMap } = args;
+  const series = [];
+  rows.forEach((row) => {
+    const seriesItem = seriesMap[row[dimension]];
+    const label = { position: "right", fontSize: 12, color: "#191919" };
+    const itemStyle = { color: SAAS_DEFAULT_COLORS[0] };
+    const lineStyle = { color: "rgba(25 ,25 ,25 , 0.10)" };
+    const symbolSize = 16;
+    const result = { type: "tree", name: row[dimension], data: row[metrics], itemStyle, label, lineStyle, symbolSize };
+    if (seriesItem) {
+      Object.keys(seriesItem).forEach((key) => {
+        if (!isObject(result[key])) {
+          result[key] = seriesItem[key];
+        } else {
+          Object.assign(result[key], seriesItem[key]);
+        }
+      });
+    }
+    series.push(result);
+  });
+  return series;
+};
+const tree = (columns, rows, settings, extra) => {
+  const { dimension = columns[0], metrics = columns[1], seriesMap = {} } = settings;
+  const { legendVisible, tooltipFormatter, tooltipVisible } = extra;
+  const seriesParam = { dimension, metrics, rows, seriesMap };
+  const series = getTreeSeries(seriesParam);
+  const legendParam = { dimension, rows };
+  const legend = legendVisible && rows.length > 1 && getTreeLegend(legendParam);
+  const tooltip = tooltipVisible && getTreeTooltip({ tooltipFormatter });
+  return { series, legend, tooltip };
+};
+export {
+  tree
+};

package/chart-waterfall/index.js

@@ -0,0 +1,99 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "../chunk-G2ADBYYC.js";
+import { getFormated } from "../chart-core/deps/utils";
+import { isNull } from "../common/type";
+import { itemLabel, itemContent, SAAS_DEFAULT_COLORS } from "../chart-core/deps/constants";
+const getWaterfallTooltip = (dataType, digit) => {
+  let trigger = "axis";
+  let axisPointer = { type: "shadow", z: 1, shadowStyle: { color: "#f5f5f5" } };
+  let formatter = function(items) {
+    const item = items[1];
+    return [
+      `${itemContent(item.name)}<br/>${itemLabel(item.seriesName)}`,
+      `${itemContent(getFormated(item.value, dataType, digit))}`
+    ].join("");
+  };
+  return { trigger, axisPointer, formatter };
+};
+const getWaterfallXAxis = (args) => {
+  const { axisVisible, dimension, labelMap, remainName, remainStatus, rows, totalName, xAxisName } = args;
+  let xAxisData = [totalName].concat(rows.map((row) => row[dimension]));
+  remainStatus === "have-remain" && (xAxisData = xAxisData.concat([remainName]));
+  let name = labelMap && labelMap[xAxisName] || xAxisName;
+  const xAxis = { type: "category", name, splitLine: { show: false }, data: xAxisData, show: axisVisible };
+  const axisLine = { show: true, lineStyle: { color: "#191919", opacity: 0.1, width: 2 } };
+  return __spreadProps(__spreadValues({}, xAxis), {
+    axisLine
+  });
+};
+const getWaterfallYAxis = (args) => {
+  const { axisVisible, dataType, digit, labelMap, yAxisName } = args;
+  let name = !isNull(labelMap[yAxisName]) ? labelMap[yAxisName] : yAxisName;
+  let formatter = function(val) {
+    return getFormated(val, dataType, digit);
+  };
+  return { type: "value", name, axisTick: { show: false }, axisLabel: { formatter }, show: axisVisible };
+};
+const getWaterfallSeries = (args) => {
+  const { dataSum, dataType, digit, metrics, remainStatus, rows, t, totalNum } = args;
+  const seriesBase = { type: "bar", stack: t("ui.chart.summation") };
+  let { dataSumTemp = dataSum, totalNumTemp = totalNum, assistData, mainData } = {};
+  const rowData = rows.map((row) => row[metrics]);
+  if (remainStatus === "have-remain") {
+    assistData = [0].concat(rows.map((row) => totalNumTemp -= row[metrics])).concat([0]);
+    mainData = [totalNum].concat(rowData).concat([totalNum - dataSum]);
+  } else {
+    assistData = [0].concat(rows.map((row) => dataSumTemp -= row[metrics]));
+    mainData = [dataSum].concat(rowData);
+  }
+  const series = [];
+  let seriesAdv = {
+    name: t("ui.chart.auxiliary"),
+    itemStyle: { opacity: 0 },
+    emphasis: { itemStyle: { opacity: 0 } },
+    data: assistData
+  };
+  series.push(Object.assign(seriesAdv, seriesBase));
+  let formatter = function(item) {
+    return getFormated(item.value, dataType, digit);
+  };
+  seriesAdv = {
+    name: t("ui.chart.value"),
+    label: { show: true, position: "top", formatter },
+    data: mainData
+  };
+  series.push(
+    Object.assign(seriesAdv, __spreadProps(__spreadValues({}, seriesBase), {
+      itemStyle: { borderRadius: [4, 4, 0, 0] },
+      color: SAAS_DEFAULT_COLORS[0]
+    }))
+  );
+  return series;
+};
+const getWaterfallRemainStatus = (dataSum, totalNum) => !totalNum ? "not-total" : totalNum <= dataSum ? "none-remain" : "have-remain";
+const waterfall = (columns, rows, settings, extra) => {
+  const { tooltipVisible, t } = extra;
+  const { axisVisible = true, dataType = "normal", dimension = columns[0] } = settings;
+  const { remainName = t("ui.chart.other"), totalName = t("ui.chart.total") } = settings;
+  const { totalNum, xAxisName = dimension, digit = 2, labelMap = {} } = settings;
+  let metricsTemp = columns.slice();
+  metricsTemp.splice(metricsTemp.indexOf(dimension), 1);
+  const { metrics = metricsTemp[0], yAxisName = metrics } = {};
+  const tooltip = tooltipVisible && getWaterfallTooltip(dataType, digit);
+  const dataSum = parseFloat(rows.reduce((pre, cur) => pre + Number(cur[metrics]), 0).toFixed(digit));
+  const remainStatus = getWaterfallRemainStatus(dataSum, totalNum);
+  const xAxisParams = { dimension, rows, remainStatus, totalName };
+  Object.assign(xAxisParams, { remainName, xAxisName, labelMap, axisVisible });
+  const xAxis = getWaterfallXAxis(xAxisParams);
+  const yAxisParams = { dataType, yAxisName, axisVisible, digit, labelMap };
+  const yAxis = getWaterfallYAxis(yAxisParams);
+  const seriesParams = { dataType, rows, dimension, metrics };
+  Object.assign(seriesParams, { totalNum, remainStatus, dataSum, digit, t });
+  const series = getWaterfallSeries(seriesParams);
+  return { series, tooltip, xAxis, yAxis };
+};
+export {
+  waterfall
+};

package/chart-wordcloud/index.js

@@ -0,0 +1,60 @@
+import "../chunk-G2ADBYYC.js";
+import { random } from "../common/string";
+import { itemLabel, itemContent } from "../chart-core/deps/constants";
+const isArr = Array.isArray;
+const getSeries = (args) => {
+  const { color, dimension, metrics, rows, shape, sizeMax, sizeMin } = args;
+  let normalColor;
+  if (!isArr(color) && !!color) {
+    normalColor = color;
+  } else {
+    normalColor = () => {
+      const rgb = [Math.round(random() * 160), Math.round(random() * 160), Math.round(random() * 160)].join(",");
+      return "rgb(" + rgb + ")";
+    };
+  }
+  let textStyle = { normal: { color: normalColor }, color: normalColor };
+  const baseType = { type: "wordCloud", textStyle, shape, sizeRange: [sizeMin, sizeMax] };
+  const len = isArr(color) ? color.length : 0;
+  baseType.data = rows.slice().map((row, i) => {
+    const text = { name: row[dimension], value: row[metrics] };
+    if (len > 0) {
+      let wordColor = color[i % len];
+      text.textStyle = {
+        normal: {
+          color: wordColor
+        },
+        color: wordColor
+      };
+    }
+    return text;
+  });
+  Object.assign(baseType, { rotationRange: [0, 0], gridSize: 10 });
+  return [baseType];
+};
+const getTooltip = (args) => {
+  const { tooltipFormatter } = args;
+  function formatter(params) {
+    const { data } = params;
+    const { name, value } = data;
+    if (tooltipFormatter) {
+      return tooltipFormatter.apply(null, params);
+    }
+    return `${itemLabel(name)}${itemContent(value)}`;
+  }
+  return { show: true, formatter };
+};
+const shapeSquare = (theta) => Math.min(1 / Math.abs(Math.cos(theta)), 1 / Math.abs(Math.sin(theta)));
+const wordcloud = (columns, rows, settings, extra) => {
+  const { dimension = columns[0], metrics = columns[1], color = "" } = settings;
+  const { sizeMax = 60, sizeMin = 12, shape } = settings;
+  const { tooltipVisible, tooltipFormatter, color: colors } = extra;
+  const seriesParams = { dimension, metrics, rows, sizeMax, sizeMin };
+  Object.assign(seriesParams, { color: color || colors, shape: shape || shapeSquare });
+  const series = getSeries(seriesParams);
+  const tooltip = tooltipVisible && getTooltip({ tooltipFormatter });
+  return { series, tooltip };
+};
+export {
+  wordcloud
+};

package/checkbox/index.js

@@ -0,0 +1,147 @@
+import "../chunk-G2ADBYYC.js";
+import { isNull } from "../common/type";
+const addToStore = ({ state, props }) => () => {
+  if (Array.isArray(state.model) && !state.model.includes(props.label)) {
+    state.model.push(props.label);
+  } else {
+    state.model = props.trueLabel || true;
+  }
+};
+const removeFromStore = ({ state, props }) => () => {
+  if (Array.isArray(state.model)) {
+    const index = state.model.indexOf(props.label);
+    index !== -1 && state.model.splice(index, 1);
+  } else {
+    state.model = props.falseLabel !== void 0 && props.falseLabel;
+  }
+};
+const handleChange = ({
+  state,
+  props,
+  emit,
+  nextTick,
+  dispatch,
+  constants
+}) => (event) => {
+  if (state.isLimitExceeded) {
+    return;
+  }
+  let moduleValue;
+  const { trueLabel, falseLabel } = props;
+  if (event.target.checked) {
+    moduleValue = trueLabel === void 0 ? true : trueLabel;
+  } else {
+    moduleValue = falseLabel === void 0 ? false : falseLabel;
+  }
+  emit("change", moduleValue, event);
+  nextTick(() => {
+    state.isGroup && dispatch(constants.CHECKBOX_GROUP, "change", [state.checkboxGroup.modelValue]);
+  });
+};
+const computedGetModelGet = ({ state, props }) => () => {
+  const model = state.isGroup ? state.store : props.modelValue !== void 0 ? props.modelValue : state.selfModel;
+  return isNull(model) ? state.isGroup ? [] : "" : model;
+};
+const computedGetModelSet = ({
+  state,
+  dispatch,
+  emit,
+  constants
+}) => (value) => {
+  if (state.isGroup) {
+    state.isLimitExceeded = false;
+    state.checkboxGroup.min !== void 0 && value.length < state.checkboxGroup.min && (state.isLimitExceeded = true);
+    state.checkboxGroup.max !== void 0 && value.length > state.checkboxGroup.max && (state.isLimitExceeded = true);
+    state.isLimitExceeded === false && dispatch(constants.CHECKBOX_GROUP, "update:modelValue", [value]);
+  } else {
+    emit("update:modelValue", value);
+    state.selfModel = value;
+  }
+};
+const computedIsChecked = ({ state, props }) => () => {
+  if (typeof state.model === "boolean") {
+    return state.model;
+  } else if (Array.isArray(state.model)) {
+    return state.model.includes(props.label);
+  } else if (!isNull(state.model)) {
+    return state.model === props.trueLabel;
+  }
+  return false;
+};
+const computedIsGroup = ({ state, parent, constants }) => () => {
+  let parentObj = parent.$parent;
+  while (parentObj) {
+    if (parentObj.$options.componentName !== constants.CHECKBOX_GROUP) {
+      parentObj = parentObj.$parent;
+    } else {
+      state.checkboxGroup = parentObj;
+      return true;
+    }
+  }
+  return false;
+};
+const computedStore = ({ state, props }) => () => state.checkboxGroup ? state.checkboxGroup.modelValue : props.modelValue;
+const computedIsLimitDisabled = (state) => () => {
+  const { max, min } = state.checkboxGroup;
+  return !!(max || min) && state.model.length >= max && !state.isChecked || state.model.length <= min && state.isChecked;
+};
+const computedIsDisabled = ({ state, props }) => () => (state.isGroup ? state.checkboxGroup.disabled || state.checkboxGroup.displayOnly || props.disabled || props.displayOnly || state.isLimitDisabled : props.disabled) || state.formDisabled;
+const computedFormItemSize = (props) => () => (props.formItem || {}).formItemSize;
+const computedCheckboxSize = ({ state, props, formItemSize }) => () => {
+  const tempCheckboxSize = props.size || formItemSize.value;
+  return state.isGroup ? state.checkboxGroup.state.checkboxGroupSize || tempCheckboxSize : tempCheckboxSize;
+};
+const mounted = ({ props, emit, api, parent }) => () => {
+  props.checked && api.addToStore();
+  props.indeterminate && parent.$el.setAttribute("aria-controls", props.controls);
+  emit("complete", true);
+};
+const toggleEvent = ({
+  parent,
+  props,
+  type
+}) => {
+  const inputEl = parent.$el;
+  for (let ev in props.events) {
+    inputEl[type + "EventListener"](ev, props.events[ev]);
+  }
+};
+const computedIsDisplayOnly = ({ state, props }) => () => props.displayOnly || state.formDisplayOnly;
+const computedIsGroupDisplayOnly = ({ state }) => () => state.isGroup && (state.checkboxGroup.displayOnly || state.formDisplayOnly);
+const computedDisplayLabel = ({ state, props, t }) => () => {
+  state.showLabel = true;
+  if (props.trueLabel !== void 0 && props.falseLabel !== void 0) {
+    return props.modelValue;
+  } else {
+    return props.modelValue ? t("yes") : t("no");
+  }
+};
+const computedIsShowText = ({ props }) => () => !isNull(props.text) || !isNull(props.label);
+const computedShowText = ({ props }) => () => {
+  if (props.text || !isNull(props.text)) {
+    return props.text;
+  } else {
+    return props.label;
+  }
+};
+export {
+  addToStore,
+  computedCheckboxSize,
+  computedDisplayLabel,
+  computedFormItemSize,
+  computedGetModelGet,
+  computedGetModelSet,
+  computedIsChecked,
+  computedIsDisabled,
+  computedIsDisplayOnly,
+  computedIsGroup,
+  computedIsGroupDisplayOnly,
+  computedIsLimitDisabled,
+  computedIsShowText,
+  computedShowText,
+  computedStore,
+  handleChange,
+  mounted,
+  removeFromStore,
+  toggleEvent
+};

package/checkbox/vue.js

@@ -0,0 +1,120 @@
+import "../chunk-G2ADBYYC.js";
+import {
+  addToStore,
+  removeFromStore,
+  handleChange,
+  computedGetModelGet,
+  computedGetModelSet,
+  computedIsChecked,
+  computedIsGroup,
+  computedStore,
+  computedIsLimitDisabled,
+  computedIsDisabled,
+  computedIsDisplayOnly,
+  computedIsGroupDisplayOnly,
+  computedFormItemSize,
+  computedCheckboxSize,
+  computedDisplayLabel,
+  mounted,
+  toggleEvent,
+  computedIsShowText,
+  computedShowText
+} from "./index";
+const api = ["state", "handleChange", "computedStore"];
+const initState = ({ reactive, computed, parent, api: api2, inject, props }) => {
+  const state = reactive({
+    size: computed(() => props.size || inject("size", null) || (parent.tinyForm || {}).size),
+    vertical: inject("vertical", null),
+    iconPosition: props.iconPosition || inject("iconPosition", "center"),
+    focus: false,
+    selfModel: false,
+    showLabel: false,
+    isLimitExceeded: false,
+    checkboxGroup: null,
+    store: computed(() => api2.computedStore()),
+    isGroup: computed(() => api2.computedIsGroup()),
+    isChecked: computed(() => api2.computedIsChecked()),
+    isDisabled: computed(() => api2.computedIsDisabled()),
+    checkboxSize: computed(() => api2.computedCheckboxSize()),
+    isLimitDisabled: computed(() => api2.computedIsLimitDisabled()),
+    formDisabled: computed(() => (parent.tinyForm || {}).disabled),
+    formDisplayOnly: computed(() => (parent.tinyForm || {}).displayOnly),
+    isDisplayOnly: computed(() => api2.computedIsDisplayOnly()),
+    isGroupDisplayOnly: computed(() => api2.computedIsGroupDisplayOnly()),
+    displayLabel: computed(() => api2.computedDisplayLabel()),
+    inputDisabled: computed(() => state.isDisabled || state.isDisplayOnly || state.isGroupDisplayOnly),
+    model: computed({
+      get: () => api2.computedGetModelGet(),
+      set: (value) => api2.computedGetModelSet(value)
+    }),
+    showText: computed(() => api2.computedShowText()),
+    isShowText: computed(() => api2.computedIsShowText()),
+    shape: inject("shape", null) || props.shape
+  });
+  return state;
+};
+const initApi = ({
+  api: api2,
+  state,
+  dispatch,
+  props,
+  parent,
+  constants,
+  formItemSize,
+  emit,
+  nextTick,
+  t,
+  vm
+}) => {
+  Object.assign(api2, {
+    state,
+    addToStore: addToStore({ state, props }),
+    removeFromStore: removeFromStore({ state, props }),
+    computedStore: computedStore({ state, props }),
+    computedFormItemSize: computedFormItemSize(props),
+    computedIsChecked: computedIsChecked({ state, props }),
+    computedIsLimitDisabled: computedIsLimitDisabled(state),
+    computedIsDisabled: computedIsDisabled({ state, props }),
+    computedIsDisplayOnly: computedIsDisplayOnly({ state, props }),
+    computedIsGroupDisplayOnly: computedIsGroupDisplayOnly({ state }),
+    computedGetModelGet: computedGetModelGet({ state, props }),
+    computedIsGroup: computedIsGroup({ state, parent, constants }),
+    computedCheckboxSize: computedCheckboxSize({ state, props, formItemSize }),
+    computedGetModelSet: computedGetModelSet({ state, dispatch, emit, constants }),
+    mounted: mounted({ emit, props, api: api2, parent }),
+    handleChange: handleChange({ state, props, emit, nextTick, dispatch, constants }),
+    computedDisplayLabel: computedDisplayLabel({ state, props, t }),
+    computedIsShowText: computedIsShowText({ props }),
+    computedShowText: computedShowText({ props })
+  });
+};
+const renderless = (props, { computed, onMounted, onBeforeUnmount, reactive, watch, inject }, { vm, parent, emit, constants, nextTick, dispatch, t }) => {
+  const api2 = { dispatch };
+  const formItemSize = computed(() => api2.computedFormItemSize());
+  const state = initState({ reactive, computed, parent, api: api2, inject, props });
+  parent.tinyForm = parent.tinyForm || inject("form", null);
+  initApi({ api: api2, state, dispatch, props, parent, constants, formItemSize, emit, nextTick, t, vm });
+  watch(
+    () => props.modelValue,
+    (value) => props.validateEvent && api2.dispatch(constants.FORM_ITEM, constants.FORM_CHANGE, value)
+  );
+  watch(
+    () => props.checked,
+    (value) => {
+      value ? api2.addToStore() : api2.removeFromStore();
+    }
+  );
+  onBeforeUnmount(() => {
+    toggleEvent({ parent, props, type: "remove" });
+  });
+  onMounted(() => {
+    dispatch("Tooltip", "tooltip-update");
+    toggleEvent({ parent, props, type: "add" });
+    api2.mounted();
+  });
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/checkbox-button/index.js

@@ -0,0 +1,68 @@
+import "../chunk-G2ADBYYC.js";
+const handleChange = ({ state, props, emit, nextTick, dispatch, constants }) => (event) => {
+  if (state.isLimitExceeded) {
+    return;
+  }
+  let value;
+  if (event.target.checked) {
+    value = props.trueLabel === void 0 ? true : props.trueLabel;
+  } else {
+    value = props.falseLabel === void 0 ? false : props.falseLabel;
+  }
+  emit("change", value, event);
+  nextTick(() => {
+    if (state.checkboxGroup) {
+      dispatch(constants.CHECKBOX_GROUP, "change", [state.checkboxGroup.modelValue]);
+    }
+  });
+};
+const computedGetModelGet = ({ state, props }) => () => state.checkboxGroup ? state.store : props.modelValue !== void 0 ? props.modelValue : state.selfModel;
+const computedGetModelSet = ({ state, props, emit, dispatch, constants }) => (value) => {
+  if (state.checkboxGroup) {
+    state.isLimitExceeded = false;
+    state.checkboxGroup.min !== void 0 && value.length < state.checkboxGroup.min && (state.isLimitExceeded = true);
+    state.checkboxGroup.max !== void 0 && value.length > state.checkboxGroup.max && (state.isLimitExceeded = true);
+    state.isLimitExceeded === false && dispatch(constants.CHECKBOX_GROUP, "update:modelValue", [value]);
+  } else if (props.modelValue !== void 0) {
+    emit("update:modelValue", value);
+  } else {
+    state.selfModel = value;
+  }
+};
+const computedCheckboxGroup = ({ parent, constants }) => () => {
+  let parentObj = parent.$parent;
+  while (parentObj) {
+    if (parentObj.$options.componentName !== constants.CHECKBOX_GROUP) {
+      parentObj = parentObj.$parent;
+    } else {
+      return parentObj;
+    }
+  }
+  return false;
+};
+const computedIsDisabled = ({ state, props }) => () => state.checkboxGroup ? state.checkboxGroup.disabled || props.disabled || state.isLimitDisabled : props.disabled;
+const computedActiveStyle = (state) => () => ({
+  backgroundColor: state.checkboxGroup.fill || "",
+  borderColor: state.checkboxGroup.fill || "",
+  color: state.checkboxGroup.textColor || "",
+  "box-shadow": "-1px 0 0 0 " + state.checkboxGroup.fill
+});
+const computedFormItemSize = (props) => () => (props.formItem || {}).formItemSize;
+const computedSize = ({ state, formItemSize }) => () => state.checkboxGroup && state.checkboxGroup.state.checkboxGroupSize || formItemSize.value;
+const toggleEvent = ({ parent, props, type }) => {
+  const inputEl = parent.$el.querySelector("input");
+  Object.keys(props.events).forEach((ev) => {
+    inputEl[type + "EventListener"](ev, props.events[ev]);
+  });
+};
+export {
+  computedActiveStyle,
+  computedCheckboxGroup,
+  computedFormItemSize,
+  computedGetModelGet,
+  computedGetModelSet,
+  computedIsDisabled,
+  computedSize,
+  handleChange,
+  toggleEvent
+};

package/checkbox-button/vue.js

@@ -0,0 +1,79 @@
+import "../chunk-G2ADBYYC.js";
+import {
+  handleChange,
+  computedGetModelGet,
+  computedGetModelSet,
+  computedCheckboxGroup,
+  computedActiveStyle,
+  computedFormItemSize,
+  computedSize,
+  computedIsDisabled,
+  toggleEvent
+} from "./index";
+import {
+  addToStore,
+  computedIsChecked,
+  computedStore,
+  computedIsLimitDisabled,
+  computedIsShowText,
+  computedShowText
+} from "../checkbox";
+const api = ["state", "handleChange"];
+const initState = ({ reactive, computed, api: api2 }) => {
+  const state = reactive({
+    focus: false,
+    selfModel: false,
+    isLimitExceeded: false,
+    model: computed({
+      get: () => api2.computedGetModelGet(),
+      set: (value) => api2.computedGetModelSet(value)
+    }),
+    size: computed(() => api2.computedSize()),
+    store: computed(() => api2.computedStore()),
+    isChecked: computed(() => api2.computedIsChecked()),
+    isDisabled: computed(() => api2.computedIsDisabled()),
+    activeStyle: computed(() => api2.computedActiveStyle()),
+    checkboxGroup: computed(() => api2.computedCheckboxGroup()),
+    isLimitDisabled: computed(() => api2.computedIsLimitDisabled()),
+    showText: computed(() => api2.computedShowText()),
+    isShowText: computed(() => api2.computedIsShowText())
+  });
+  return state;
+};
+const initApi = ({ api: api2, state, props, formItemSize, parent, constants, emit, nextTick, dispatch }) => {
+  Object.assign(api2, {
+    state,
+    addToStore: addToStore({ state, props }),
+    computedStore: computedStore({ state, props }),
+    computedActiveStyle: computedActiveStyle(state),
+    computedFormItemSize: computedFormItemSize(props),
+    computedSize: computedSize({ state, formItemSize }),
+    computedIsChecked: computedIsChecked({ state, props }),
+    computedIsLimitDisabled: computedIsLimitDisabled(state),
+    computedIsDisabled: computedIsDisabled({ state, props }),
+    computedGetModelGet: computedGetModelGet({ state, props }),
+    computedCheckboxGroup: computedCheckboxGroup({ parent, constants }),
+    handleChange: handleChange({ state, props, emit, nextTick, dispatch, constants }),
+    computedGetModelSet: computedGetModelSet({ state, props, emit, dispatch, constants }),
+    computedIsShowText: computedIsShowText({ props }),
+    computedShowText: computedShowText({ props })
+  });
+};
+const renderless = (props, { computed, onMounted, onBeforeUnmount, reactive }, { parent, emit, dispatch, constants, nextTick }) => {
+  const api2 = {};
+  const formItemSize = computed(() => api2.computedFormItemSize());
+  const state = initState({ reactive, computed, api: api2 });
+  initApi({ api: api2, state, props, formItemSize, parent, constants, emit, nextTick, dispatch });
+  onBeforeUnmount(() => {
+    toggleEvent({ parent, props, type: "remove" });
+  });
+  onMounted(() => {
+    toggleEvent({ parent, props, type: "add" });
+    props.checked && api2.addToStore();
+  });
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/checkbox-group/index.js

@@ -0,0 +1,7 @@
+import "../chunk-G2ADBYYC.js";
+const computedFormItemSize = (props) => () => (props.formItem || {}).formItemSize;
+const computedCheckboxGroupSize = ({ props, formItemSize }) => () => props.size || formItemSize.value;
+export {
+  computedCheckboxGroupSize,
+  computedFormItemSize
+};

package/checkbox-group/vue.js

@@ -0,0 +1,29 @@
+import "../chunk-G2ADBYYC.js";
+import { computedFormItemSize, computedCheckboxGroupSize } from "./index";
+const api = ["state"];
+const renderless = (props, { computed, reactive, watch, provide }, { dispatch, constants }) => {
+  const api2 = {
+    computedFormItemSize: computedFormItemSize(props)
+  };
+  const formItemSize = computed(() => api2.computedFormItemSize());
+  const state = reactive({
+    checkboxGroupSize: computed(() => api2.computedCheckboxGroupSize())
+  });
+  Object.assign(api2, {
+    state,
+    computedCheckboxGroupSize: computedCheckboxGroupSize({ props, formItemSize })
+  });
+  watch(
+    () => props.modelValue,
+    (value) => dispatch(constants.FORM_ITEM, constants.FORM_CHANGE, [value])
+  );
+  provide("size", props.size);
+  provide("vertical", props.vertical);
+  provide("iconPosition", props.iconPosition);
+  provide("shape", props.shape);
+  return api2;
+};
+export {
+  api,
+  renderless
+};