@form-renderer/preset-element-plus/dist/index.js

ElementPlus preset for form-renderer

import { buildValidationContext as J } from "@form-renderer/adapter-vue3";
import { defineComponent as y, createBlock as f, openBlock as r, unref as h, mergeProps as g, withCtx as w, createElementBlock as p, Fragment as M, renderList as A, createTextVNode as L, toDisplayString as T, ref as j, watch as Q, createVNode as V, createElementVNode as P, createCommentVNode as x, resolveComponent as F, renderSlot as E, computed as $, normalizeClass as Y, createSlots as X } from "vue";
import { ElInput as G, ElInputNumber as Z, ElSwitch as _, ElCheckboxGroup as ee, ElCheckbox as te, ElRadioGroup as ae, ElRadio as le, ElSelect as oe, ElOption as ne, ElDatePicker as re, ElCascader as se, ElTimePicker as ie, ElSlider as de, ElRate as ce, ElColorPicker as ue, ElUpload as me, ElIcon as O, ElButton as fe, ElFormItem as he } from "element-plus";
import { Plus as pe, UploadFilled as ge } from "@element-plus/icons-vue";
const R = {
  toComponent: (e) => e == null ? "" : String(e),
  fromComponent: (e) => e
}, U = {
  toComponent: (e) => {
    if (e == null || e === "")
      return;
    const o = Number(e);
    return isNaN(o) ? void 0 : o;
  },
  fromComponent: (e) => e
}, ve = {
  toComponent: (e) => typeof e == "boolean" ? e : typeof e == "string" ? e === "true" || e === "1" : typeof e == "number" ? e !== 0 : !!e,
  fromComponent: (e) => e
}, ye = {
  toComponent: (e) => {
    if (Array.isArray(e))
      return e;
    if (e == null)
      return [];
    if (typeof e == "string")
      try {
        const o = JSON.parse(e);
        return Array.isArray(o) ? o : [e];
      } catch {
        return [e];
      }
    return [e];
  },
  fromComponent: (e) => e
}, q = {
  toComponent: (e) => {
    if (e == null || e === "")
      return null;
    if (e instanceof Date)
      return e;
    if (typeof e == "string") {
      const o = new Date(e);
      return isNaN(o.getTime()) ? null : e;
    }
    return typeof e == "number" ? new Date(e) : null;
  },
  fromComponent: (e) => e == null ? null : e instanceof Date ? e.toISOString().split("T")[0] : e
}, H = {
  toComponent: (e) => e,
  fromComponent: (e) => e ?? ""
}, be = {
  toComponent: (e) => Array.isArray(e) ? e : e == null || e === "" ? [] : [e],
  fromComponent: (e) => e
}, we = {
  toComponent: (e) => Array.isArray(e) ? e : e == null ? [] : [e],
  fromComponent: (e) => e
};
function C(e) {
  return {
    input: R,
    textarea: R,
    number: U,
    switch: ve,
    "checkbox-group": be,
    "radio-group": H,
    select: H,
    "date-picker": q,
    "time-picker": q,
    cascader: ye,
    slider: U,
    rate: U,
    "color-picker": R,
    upload: we
  }[e];
}
const I = {
  onChange: "change",
  onFocus: "focus",
  onBlur: "blur",
  onClear: "clear"
}, W = {
  ...I,
  onInput: "input",
  onKeydown: "keydown",
  onKeyup: "keyup",
  onEnter: "keydown.enter"
}, Ce = {
  ...I,
  onInput: "input"
}, xe = {
  onChange: "update:modelValue"
}, D = {
  ...I,
  onVisibleChange: "visible-change",
  onRemoveTag: "remove-tag"
}, N = {
  ...I,
  onCalendarChange: "calendar-change",
  onPanelChange: "panel-change",
  onVisibleChange: "visible-change"
}, Be = {
  onValidate: "validate",
  onSubmit: "submit",
  onReset: "reset"
}, Te = {
  onChange: "update:modelValue",
  onAdd: "add",
  onRemove: "remove",
  onSort: "sort",
  onMove: "move"
}, ke = {
  onChange: "change",
  onTabChange: "tab-change",
  onCollapseChange: "change"
}, ze = {
  ...I,
  onVisibleChange: "visible-change",
  onExpandChange: "expand-change"
}, Ee = {
  onChange: "change",
  onInput: "input"
}, Pe = {
  onChange: "update:modelValue"
}, Me = {
  onChange: "update:modelValue",
  onActiveChange: "active-change"
}, Ie = {
  onChange: "change",
  onPreview: "preview",
  onRemove: "remove",
  onSuccess: "success",
  onError: "error",
  onProgress: "progress",
  onExceed: "exceed"
};
function b(e) {
  return {
    input: W,
    textarea: W,
    number: Ce,
    switch: xe,
    "checkbox-group": D,
    "radio-group": D,
    select: D,
    "date-picker": N,
    "time-picker": N,
    "datetime-picker": N,
    cascader: ze,
    slider: Ee,
    rate: Pe,
    "color-picker": Me,
    upload: Ie,
    form: Be,
    layout: ke,
    list: Te
  }[e] || I;
}
function Tt(e, o) {
  const a = {};
  return Object.entries(e).forEach(([n, l]) => {
    a[n] = l;
  }), Object.entries(o).forEach(([n, l]) => {
    l !== void 0 && (a[n] = l);
  }), a;
}
const kt = {
  /**
   * 合并多个事件映射
   */
  merge: (...e) => {
    const o = {};
    return e.forEach((a) => {
      Object.entries(a).forEach(([n, l]) => {
        o[n] = l;
      });
    }), o;
  },
  /**
   * 过滤事件映射
   */
  filter: (e, o) => {
    const a = {};
    return Object.entries(e).forEach(([n, l]) => {
      o(n, l) && (a[n] = l);
    }), a;
  },
  /**
   * 转换事件映射
   */
  transform: (e, o) => {
    const a = {};
    return Object.entries(e).forEach(([n, l]) => {
      const [t, s] = o(n, l);
      a[t] = s;
    }), a;
  }
};
function K(e, o, a) {
  const n = J(
    { validators: e.validators, required: e.required },
    o
  );
  if (!n.shouldValidate)
    return [];
  const l = [];
  return n.required && l.push({
    required: !0,
    message: `${e.label || "此项"}不能为空`,
    trigger: "change"
  }), n.validators.forEach((t) => {
    const s = {
      validator: (d, B, v) => {
        try {
          const k = {
            path: e.path,
            // 获取 Schema
            getSchema: (m) => e,
            // 获取表单数据 - 关键！
            getValue: (m) => m ? a.engine?.getEngine().getValue(m) : B,
            // TODO: 支持 list 场景
            getCurRowValue: () => ({}),
            getCurRowIndex: () => -1
          }, i = t(B, k);
          if (i instanceof Promise)
            i.then((m) => {
              if (m === !0 || m === void 0 || m === null)
                v();
              else if (m === !1)
                v(new Error("校验失败"));
              else if (typeof m == "string")
                v(new Error(m));
              else if (typeof m == "object" && m !== null) {
                const u = "message" in m ? m.message : "校验失败";
                v(new Error(u));
              } else
                v();
            }).catch((m) => {
              v(new Error(m.message || "校验出错"));
            });
          else if (i === !0 || i === void 0 || i === null)
            v();
          else if (i === !1)
            v(new Error("校验失败"));
          else if (typeof i == "string")
            v(new Error(i));
          else if (typeof i == "object" && i !== null) {
            const m = "message" in i ? i.message : "校验失败";
            v(new Error(m));
          } else
            v();
        } catch (k) {
          v(new Error(k.message || "校验出错"));
        }
      },
      trigger: "blur"
      // 默认失焦时触发
    };
    l.push(s);
  }), l;
}
const Fe = /* @__PURE__ */ y({
  __name: "Input",
  props: {
    type: { default: "text" },
    size: { default: "default" },
    clearable: { type: Boolean, default: !1 },
    showPassword: { type: Boolean, default: !1 },
    maxlength: {},
    minlength: {},
    showWordLimit: { type: Boolean, default: !1 },
    prefixIcon: {},
    suffixIcon: {},
    readonly: { type: Boolean, default: !1 },
    autofocus: { type: Boolean, default: !1 },
    modelValue: {},
    onChange: {},
    disabled: { type: Boolean },
    placeholder: {}
  },
  emits: ["change"],
  setup(e, { emit: o }) {
    const a = e, n = o, l = (t) => {
      a.onChange?.(t), n("change", t);
    };
    return (t, s) => (r(), f(h(G), g({
      "model-value": e.modelValue,
      "onUpdate:modelValue": l,
      disabled: e.disabled,
      placeholder: e.placeholder,
      size: e.size,
      clearable: e.clearable,
      "show-password": e.showPassword,
      type: e.type,
      maxlength: e.maxlength,
      minlength: e.minlength,
      "show-word-limit": e.showWordLimit,
      "prefix-icon": e.prefixIcon,
      "suffix-icon": e.suffixIcon,
      readonly: e.readonly,
      autofocus: e.autofocus
    }, t.$attrs), null, 16, ["model-value", "disabled", "placeholder", "size", "clearable", "show-password", "type", "maxlength", "minlength", "show-word-limit", "prefix-icon", "suffix-icon", "readonly", "autofocus"]));
  }
}), $e = /* @__PURE__ */ y({
  __name: "InputNumber",
  props: {
    size: { default: "default" },
    min: {},
    max: {},
    step: { default: 1 },
    precision: {},
    controls: { type: Boolean, default: !0 },
    controlsPosition: { default: "right" },
    readonly: { type: Boolean, default: !1 },
    modelValue: {},
    onChange: {},
    disabled: { type: Boolean },
    placeholder: {}
  },
  emits: ["change"],
  setup(e, { emit: o }) {
    const a = e, n = o, l = (t) => {
      a.onChange?.(t), n("change", t);
    };
    return (t, s) => (r(), f(h(Z), g({
      "model-value": t.value,
      "onUpdate:modelValue": l,
      disabled: e.disabled,
      placeholder: e.placeholder,
      size: e.size,
      min: e.min,
      max: e.max,
      step: e.step,
      precision: e.precision,
      controls: e.controls,
      "controls-position": e.controlsPosition,
      readonly: e.readonly
    }, t.$attrs), null, 16, ["model-value", "disabled", "placeholder", "size", "min", "max", "step", "precision", "controls", "controls-position", "readonly"]));
  }
}), Se = /* @__PURE__ */ y({
  __name: "Switch",
  props: {
    size: { default: "default" },
    width: {},
    inlinePrompt: { type: Boolean, default: !1 },
    activeText: {},
    inactiveText: {},
    activeValue: { type: [Boolean, String, Number], default: !0 },
    inactiveValue: { type: [Boolean, String, Number], default: !1 },
    activeColor: {},
    inactiveColor: {},
    borderColor: {},
    modelValue: {},
    onChange: {},
    readonly: { type: Boolean },
    disabled: { type: Boolean },
    placeholder: {}
  },
  emits: ["change"],
  setup(e, { emit: o }) {
    const a = e, n = o, l = (t) => {
      a.onChange?.(t), n("change", t);
    };
    return (t, s) => (r(), f(h(_), g({
      "model-value": e.modelValue,
      "onUpdate:modelValue": l,
      disabled: e.disabled,
      size: e.size,
      width: e.width,
      "inline-prompt": e.inlinePrompt,
      "active-text": e.activeText,
      "inactive-text": e.inactiveText,
      "active-value": e.activeValue,
      "inactive-value": e.inactiveValue,
      "active-color": e.activeColor,
      "inactive-color": e.inactiveColor,
      "border-color": e.borderColor
    }, t.$attrs), null, 16, ["model-value", "disabled", "size", "width", "inline-prompt", "active-text", "inactive-text", "active-value", "inactive-value", "active-color", "inactive-color", "border-color"]));
  }
}), Ve = /* @__PURE__ */ y({
  __name: "CheckboxGroup",
  props: {
    options: { default: () => [] },
    size: { default: "default" },
    min: {},
    max: {},
    modelValue: {},
    onChange: {},
    readonly: { type: Boolean },
    disabled: { type: Boolean },
    placeholder: {}
  },
  emits: ["change"],
  setup(e, { emit: o }) {
    const a = e, n = o, l = (t) => {
      console.log("----", t), a.onChange?.(t), n("change", t);
    };
    return (t, s) => (r(), f(h(ee), g({
      "model-value": t.value,
      "onUpdate:modelValue": l,
      disabled: e.disabled,
      size: e.size,
      min: e.min,
      max: e.max
    }, t.$attrs), {
      default: w(() => [
        (r(!0), p(M, null, A(e.options, (d) => (r(), f(h(te), {
          key: String(d.value),
          label: d.value,
          disabled: d.disabled
        }, {
          default: w(() => [
            L(T(d.label), 1)
          ]),
          _: 2
        }, 1032, ["label", "disabled"]))), 128))
      ]),
      _: 1
    }, 16, ["model-value", "disabled", "size", "min", "max"]));
  }
}), Ae = /* @__PURE__ */ y({
  __name: "RadioGroup",
  props: {
    modelValue: { type: [String, Number, Boolean] },
    options: { default: () => [] },
    size: { default: "default" },
    onChange: {},
    readonly: { type: Boolean },
    disabled: { type: Boolean },
    placeholder: {}
  },
  emits: ["change"],
  setup(e, { emit: o }) {
    const a = e, n = o, l = (t) => {
      t !== void 0 && (a.onChange?.(t), n("change", t));
    };
    return (t, s) => (r(), f(h(ae), g({
      "model-value": e.modelValue,
      "onUpdate:modelValue": l,
      disabled: e.disabled,
      size: e.size
    }, t.$attrs), {
      default: w(() => [
        (r(!0), p(M, null, A(e.options, (d) => (r(), f(h(le), {
          key: String(d.value),
          label: d.value,
          disabled: d.disabled
        }, {
          default: w(() => [
            L(T(d.label), 1)
          ]),
          _: 2
        }, 1032, ["label", "disabled"]))), 128))
      ]),
      _: 1
    }, 16, ["model-value", "disabled", "size"]));
  }
}), Re = /* @__PURE__ */ y({
  __name: "Select",
  props: {
    options: { default: () => [] },
    size: { default: "default" },
    clearable: { type: Boolean, default: !1 },
    filterable: { type: Boolean, default: !1 },
    multiple: { type: Boolean, default: !1 },
    placeholder: {},
    loading: { type: Boolean, default: !1 },
    loadingText: {},
    noDataText: {},
    noMatchText: {},
    remote: { type: Boolean, default: !1 },
    remoteMethod: {},
    allowCreate: { type: Boolean, default: !1 },
    defaultFirstOption: { type: Boolean, default: !1 },
    reserveKeyword: { type: Boolean, default: !0 },
    collapseTags: { type: Boolean, default: !1 },
    collapseTagsTooltip: { type: Boolean, default: !1 },
    multipleLimit: { default: 0 },
    modelValue: {},
    onChange: {},
    readonly: { type: Boolean },
    disabled: { type: Boolean }
  },
  emits: ["change"],
  setup(e, { emit: o }) {
    const a = e, n = o, l = (t) => {
      a.onChange?.(t), n("change", t);
    };
    return (t, s) => (r(), f(h(oe), g({
      "model-value": e.modelValue,
      "onUpdate:modelValue": l,
      disabled: e.disabled,
      size: e.size,
      clearable: e.clearable,
      filterable: e.filterable,
      multiple: e.multiple,
      placeholder: e.placeholder,
      loading: e.loading,
      "loading-text": e.loadingText,
      "no-data-text": e.noDataText,
      "no-match-text": e.noMatchText,
      remote: e.remote,
      "remote-method": e.remoteMethod,
      "allow-create": e.allowCreate,
      "default-first-option": e.defaultFirstOption,
      "reserve-keyword": e.reserveKeyword,
      "collapse-tags": e.collapseTags,
      "collapse-tags-tooltip": e.collapseTagsTooltip,
      "multiple-limit": e.multipleLimit
    }, t.$attrs), {
      default: w(() => [
        (r(!0), p(M, null, A(e.options, (d) => (r(), f(h(ne), {
          key: String(d.value),
          label: d.label,
          value: d.value,
          disabled: d.disabled
        }, null, 8, ["label", "value", "disabled"]))), 128))
      ]),
      _: 1
    }, 16, ["model-value", "disabled", "size", "clearable", "filterable", "multiple", "placeholder", "loading", "loading-text", "no-data-text", "no-match-text", "remote", "remote-method", "allow-create", "default-first-option", "reserve-keyword", "collapse-tags", "collapse-tags-tooltip", "multiple-limit"]));
  }
}), Ue = /* @__PURE__ */ y({
  __name: "DatePicker",
  props: {
    type: { default: "date" },
    size: { default: "default" },
    format: {},
    valueFormat: {},
    placeholder: {},
    startPlaceholder: {},
    endPlaceholder: {},
    clearable: { type: Boolean, default: !0 },
    readonly: { type: Boolean, default: !1 },
    editable: { type: Boolean, default: !0 },
    prefixIcon: {},
    clearIcon: {},
    shortcuts: {},
    disabledDate: {},
    cellClassName: {},
    rangeSeparator: { default: "-" },
    defaultValue: {},
    defaultTime: {},
    teleported: { type: Boolean, default: !0 },
    modelValue: {},
    onChange: {},
    disabled: { type: Boolean }
  },
  emits: ["change"],
  setup(e, { emit: o }) {
    const a = e, n = o, l = (t) => {
      a.onChange?.(t), n("change", t);
    };
    return (t, s) => (r(), f(h(re), g({
      "model-value": e.modelValue,
      "onUpdate:modelValue": l,
      disabled: e.disabled,
      size: e.size,
      type: e.type,
      format: e.format,
      "value-format": e.valueFormat,
      placeholder: e.placeholder,
      "start-placeholder": e.startPlaceholder,
      "end-placeholder": e.endPlaceholder,
      clearable: e.clearable,
      readonly: e.readonly,
      editable: e.editable,
      "prefix-icon": e.prefixIcon,
      "clear-icon": e.clearIcon,
      shortcuts: e.shortcuts,
      "disabled-date": e.disabledDate,
      "cell-class-name": e.cellClassName,
      "range-separator": e.rangeSeparator,
      "default-value": e.defaultValue,
      "default-time": e.defaultTime,
      teleported: e.teleported
    }, t.$attrs), null, 16, ["model-value", "disabled", "size", "type", "format", "value-format", "placeholder", "start-placeholder", "end-placeholder", "clearable", "readonly", "editable", "prefix-icon", "clear-icon", "shortcuts", "disabled-date", "cell-class-name", "range-separator", "default-value", "default-time", "teleported"]));
  }
}), De = /* @__PURE__ */ y({
  __name: "Textarea",
  props: {
    size: { default: "default" },
    rows: { default: 3 },
    autosize: { type: [Boolean, Object], default: !1 },
    maxlength: {},
    minlength: {},
    showWordLimit: { type: Boolean, default: !1 },
    readonly: { type: Boolean, default: !1 },
    autofocus: { type: Boolean, default: !1 },
    resize: { default: "vertical" },
    modelValue: {},
    onChange: {},
    disabled: { type: Boolean },
    placeholder: {}
  },
  emits: ["change"],
  setup(e, { emit: o }) {
    const a = e, n = o, l = (t) => {
      a.onChange?.(t), n("change", t);
    };
    return (t, s) => (r(), f(h(G), g({
      "model-value": e.modelValue,
      "onUpdate:modelValue": l,
      type: "textarea",
      disabled: e.disabled,
      placeholder: e.placeholder,
      size: e.size,
      rows: e.rows,
      autosize: e.autosize,
      maxlength: e.maxlength,
      minlength: e.minlength,
      "show-word-limit": e.showWordLimit,
      readonly: e.readonly,
      autofocus: e.autofocus,
      resize: e.resize
    }, t.$attrs), null, 16, ["model-value", "disabled", "placeholder", "size", "rows", "autosize", "maxlength", "minlength", "show-word-limit", "readonly", "autofocus", "resize"]));
  }
}), Ne = /* @__PURE__ */ y({
  __name: "Cascader",
  props: {
    options: { default: () => [] },
    size: { default: "default" },
    clearable: { type: Boolean, default: !0 },
    filterable: { type: Boolean, default: !1 },
    showAllLevels: { type: Boolean, default: !0 },
    collapseTags: { type: Boolean, default: !1 },
    collapseTagsTooltip: { type: Boolean, default: !1 },
    separator: { default: " / " },
    cascaderProps: {},
    onVisibleChange: {},
    modelValue: {},
    onChange: {},
    readonly: { type: Boolean },
    disabled: { type: Boolean },
    placeholder: {}
  },
  emits: ["change", "visible-change"],
  setup(e, { emit: o }) {
    const a = e, n = o, l = (d) => {
      a.onChange?.(d), n("change", d);
    }, t = (d) => {
    }, s = (d) => {
      a.onVisibleChange?.(d), n("visible-change", d);
    };
    return (d, B) => (r(), f(h(se), g({
      "model-value": d.value,
      "onUpdate:modelValue": l,
      options: e.options,
      disabled: e.disabled,
      placeholder: e.placeholder,
      size: e.size,
      clearable: e.clearable,
      filterable: e.filterable,
      "show-all-levels": e.showAllLevels,
      "collapse-tags": e.collapseTags,
      "collapse-tags-tooltip": e.collapseTagsTooltip,
      separator: e.separator,
      props: e.cascaderProps
    }, d.$attrs, {
      onChange: t,
      onVisibleChange: s
    }), null, 16, ["model-value", "options", "disabled", "placeholder", "size", "clearable", "filterable", "show-all-levels", "collapse-tags", "collapse-tags-tooltip", "separator", "props"]));
  }
}), Le = /* @__PURE__ */ y({
  __name: "TimePicker",
  props: {
    size: { default: "default" },
    clearable: { type: Boolean, default: !0 },
    format: { default: "HH:mm:ss" },
    valueFormat: { default: "HH:mm:ss" },
    isRange: { type: Boolean, default: !1 },
    startPlaceholder: { default: "开始时间" },
    endPlaceholder: { default: "结束时间" },
    rangeSeparator: { default: "-" },
    arrowControl: { type: Boolean, default: !1 },
    editable: { type: Boolean, default: !0 },
    modelValue: {},
    onChange: {},
    readonly: { type: Boolean },
    disabled: { type: Boolean },
    placeholder: {}
  },
  emits: ["change"],
  setup(e, { emit: o }) {
    const a = e, n = o, l = (t) => {
      a.onChange?.(t), n("change", t);
    };
    return (t, s) => (r(), f(h(ie), g({
      "model-value": t.value,
      "onUpdate:modelValue": l,
      disabled: e.disabled,
      placeholder: e.placeholder,
      size: e.size,
      clearable: e.clearable,
      format: e.format,
      "value-format": e.valueFormat,
      "is-range": e.isRange,
      "start-placeholder": e.startPlaceholder,
      "end-placeholder": e.endPlaceholder,
      "range-separator": e.rangeSeparator,
      "arrow-control": e.arrowControl,
      editable: e.editable
    }, t.$attrs), null, 16, ["model-value", "disabled", "placeholder", "size", "clearable", "format", "value-format", "is-range", "start-placeholder", "end-placeholder", "range-separator", "arrow-control", "editable"]));
  }
}), Oe = /* @__PURE__ */ y({
  __name: "Slider",
  props: {
    size: { default: "default" },
    min: { default: 0 },
    max: { default: 100 },
    step: { default: 1 },
    showInput: { type: Boolean, default: !1 },
    showInputControls: { type: Boolean, default: !0 },
    showStops: { type: Boolean, default: !1 },
    showTooltip: { type: Boolean, default: !0 },
    formatTooltip: {},
    range: { type: Boolean, default: !1 },
    vertical: { type: Boolean, default: !1 },
    height: {},
    marks: {},
    modelValue: {},
    onChange: {},
    readonly: { type: Boolean },
    disabled: { type: Boolean },
    placeholder: {}
  },
  emits: ["change"],
  setup(e, { emit: o }) {
    const a = e, n = o, l = (s) => {
      a.onChange?.(s), n("change", s);
    }, t = (s) => {
    };
    return (s, d) => (r(), f(h(de), g({
      "model-value": s.value,
      "onUpdate:modelValue": l,
      disabled: e.disabled,
      size: e.size,
      min: e.min,
      max: e.max,
      step: e.step,
      "show-input": e.showInput,
      "show-input-controls": e.showInputControls,
      "show-stops": e.showStops,
      "show-tooltip": e.showTooltip,
      "format-tooltip": e.formatTooltip,
      range: e.range,
      vertical: e.vertical,
      height: e.height,
      marks: e.marks
    }, s.$attrs, { onChange: t }), null, 16, ["model-value", "disabled", "size", "min", "max", "step", "show-input", "show-input-controls", "show-stops", "show-tooltip", "format-tooltip", "range", "vertical", "height", "marks"]));
  }
}), qe = /* @__PURE__ */ y({
  __name: "Rate",
  props: {
    size: { default: "default" },
    max: { default: 5 },
    allowHalf: { type: Boolean, default: !1 },
    lowThreshold: { default: 2 },
    highThreshold: { default: 4 },
    colors: {},
    voidColor: {},
    disabledVoidColor: {},
    icons: {},
    voidIcon: {},
    disabledVoidIcon: {},
    showText: { type: Boolean, default: !1 },
    showScore: { type: Boolean, default: !1 },
    textColor: {},
    texts: {},
    scoreTemplate: {},
    modelValue: {},
    onChange: {},
    readonly: { type: Boolean },
    disabled: { type: Boolean },
    placeholder: {}
  },
  emits: ["change"],
  setup(e, { emit: o }) {
    const a = e, n = o, l = (t) => {
      a.onChange?.(t), n("change", t);
    };
    return (t, s) => (r(), f(h(ce), g({
      "model-value": t.value,
      "onUpdate:modelValue": l,
      disabled: e.disabled,
      size: e.size,
      max: e.max,
      "allow-half": e.allowHalf,
      "low-threshold": e.lowThreshold,
      "high-threshold": e.highThreshold,
      colors: e.colors,
      "void-color": e.voidColor,
      "disabled-void-color": e.disabledVoidColor,
      icons: e.icons,
      "void-icon": e.voidIcon,
      "disabled-void-icon": e.disabledVoidIcon,
      "show-text": e.showText,
      "show-score": e.showScore,
      "text-color": e.textColor,
      texts: e.texts,
      "score-template": e.scoreTemplate
    }, t.$attrs), null, 16, ["model-value", "disabled", "size", "max", "allow-half", "low-threshold", "high-threshold", "colors", "void-color", "disabled-void-color", "icons", "void-icon", "disabled-void-icon", "show-text", "show-score", "text-color", "texts", "score-template"]));
  }
}), He = /* @__PURE__ */ y({
  __name: "ColorPicker",
  props: {
    size: { default: "default" },
    showAlpha: { type: Boolean, default: !1 },
    colorFormat: { default: "hex" },
    predefine: {},
    onActiveChange: {},
    modelValue: {},
    onChange: {},
    readonly: { type: Boolean },
    disabled: { type: Boolean },
    placeholder: {}
  },
  emits: ["change", "active-change"],
  setup(e, { emit: o }) {
    const a = e, n = o, l = (s) => {
      a.onChange?.(s), n("change", s);
    }, t = (s) => {
      a.onActiveChange?.(s), n("active-change", s);
    };
    return (s, d) => (r(), f(h(ue), g({
      "model-value": s.value,
      "onUpdate:modelValue": l,
      disabled: e.disabled,
      size: e.size,
      "show-alpha": e.showAlpha,
      "color-format": e.colorFormat,
      predefine: e.predefine
    }, s.$attrs, { onActiveChange: t }), null, 16, ["model-value", "disabled", "size", "show-alpha", "color-format", "predefine"]));
  }
}), We = { class: "el-upload__text" }, je = {
  key: 0,
  class: "el-upload__tip"
}, Ye = {
  key: 0,
  class: "el-upload__tip"
}, Ge = /* @__PURE__ */ y({
  __name: "Upload",
  props: {
    action: { default: "" },
    headers: {},
    method: { default: "post" },
    data: {},
    name: { default: "file" },
    withCredentials: { type: Boolean, default: !1 },
    multiple: { type: Boolean, default: !1 },
    accept: {},
    size: { default: "default" },
    limit: {},
    drag: { type: Boolean, default: !1 },
    listType: { default: "text" },
    autoUpload: { type: Boolean, default: !0 },
    showFileList: { type: Boolean, default: !0 },
    buttonText: {},
    dragText: {},
    tip: {},
    onPreview: {},
    onRemove: {},
    onSuccess: {},
    onError: {},
    onProgress: {},
    onExceed: {},
    beforeUpload: {},
    beforeRemove: {},
    modelValue: {},
    onChange: {},
    readonly: { type: Boolean },
    disabled: { type: Boolean },
    placeholder: {}
  },
  emits: ["change"],
  setup(e, { emit: o }) {
    const a = e, n = o, l = j([]);
    Q(
      () => a.value,
      (u) => {
        Array.isArray(u) && (l.value = u.map((c) => typeof c == "string" ? {
          name: c.split("/").pop() || "",
          url: c,
          status: "success",
          uid: Date.now() + Math.random()
        } : c));
      },
      { immediate: !0 }
    );
    const t = (u) => {
      a.onChange?.(u), n("change", u);
    }, s = (u, c) => {
      l.value = c, t(c);
    }, d = (u) => {
      a.onPreview?.(u);
    }, B = (u, c) => {
      l.value = c, a.onRemove?.(u, c), t(c);
    }, v = (u, c, z) => {
      a.onSuccess?.(u, c, z), t(z);
    }, k = (u, c, z) => {
      a.onError?.(u, c, z);
    }, i = (u, c, z) => {
      a.onProgress?.(u, c, z);
    }, m = (u, c) => {
      a.onExceed?.(u, c);
    };
    return (u, c) => (r(), f(h(me), g({
      "model-value": u.value,
      "onUpdate:modelValue": t,
      action: e.action,
      headers: e.headers,
      method: e.method,
      data: e.data,
      name: e.name,
      "with-credentials": e.withCredentials,
      multiple: e.multiple,
      accept: e.accept,
      disabled: e.disabled,
      limit: e.limit,
      drag: e.drag,
      "file-list": l.value,
      "list-type": e.listType,
      "auto-upload": e.autoUpload,
      "show-file-list": e.showFileList,
      "on-preview": d,
      "on-remove": B,
      "on-success": v,
      "on-error": k,
      "on-progress": i,
      "on-change": s,
      "on-exceed": m,
      "before-upload": e.beforeUpload,
      "before-remove": e.beforeRemove
    }, u.$attrs), {
      default: w(() => [
        e.listType === "picture-card" ? (r(), f(h(O), { key: 0 }, {
          default: w(() => [
            V(h(pe))
          ]),
          _: 1
        })) : e.drag ? (r(), p(M, { key: 1 }, [
          V(h(O), { class: "el-icon--upload" }, {
            default: w(() => [
              V(h(ge))
            ]),
            _: 1
          }),
          P("div", We, T(e.dragText || "将文件拖到此处，或<em>点击上传</em>"), 1),
          e.tip ? (r(), p("div", je, T(e.tip), 1)) : x("", !0)
        ], 64)) : (r(), p(M, { key: 2 }, [
          V(h(fe), {
            type: "primary",
            size: e.size
          }, {
            default: w(() => [
              L(T(e.buttonText || "点击上传"), 1)
            ]),
            _: 1
          }, 8, ["size"]),
          e.tip ? (r(), p("div", Ye, T(e.tip), 1)) : x("", !0)
        ], 64))
      ]),
      _: 1
    }, 16, ["model-value", "action", "headers", "method", "data", "name", "with-credentials", "multiple", "accept", "disabled", "limit", "drag", "file-list", "list-type", "auto-upload", "show-file-list", "before-upload", "before-remove"]));
  }
}), S = (e, o) => {
  const a = e.__vccOpts || e;
  for (const [n, l] of o)
    a[n] = l;
  return a;
}, Ke = /* @__PURE__ */ S(Ge, [["__scopeId", "data-v-e941592a"]]), Je = /* @__PURE__ */ y({
  __name: "Form",
  props: {
    modelValue: {},
    rules: {},
    labelPosition: { default: "right" },
    labelWidth: { default: "100px" },
    size: { default: "default" },
    disabled: { type: Boolean, default: !1 },
    validateOnRuleChange: { type: Boolean, default: !0 },
    hideRequiredAsterisk: { type: Boolean, default: !1 },
    showMessage: { type: Boolean, default: !0 },
    inlineMessage: { type: Boolean, default: !1 },
    statusIcon: { type: Boolean, default: !1 }
  },
  emits: ["update:modelValue", "validate"],
  setup(e, { expose: o, emit: a }) {
    const n = a, l = j(), t = (i, m, u) => {
      n("validate", i, m, u);
    };
    return o({
      validate: (i) => l.value?.validate(i),
      validateField: (i, m) => l.value?.validateField(i, m),
      resetFields: () => {
        l.value?.resetFields();
      },
      scrollToField: (i) => {
        l.value?.scrollToField(i);
      },
      clearValidate: (i) => {
        l.value?.clearValidate(i);
      },
      formRef: l
    }), (i, m) => {
      const u = F("el-form");
      return r(), f(u, g({
        ref_key: "formRef",
        ref: l,
        model: e.modelValue,
        rules: e.rules,
        "label-position": e.labelPosition,
        "label-width": e.labelWidth,
        size: e.size,
        disabled: e.disabled,
        "validate-on-rule-change": e.validateOnRuleChange,
        "hide-required-asterisk": e.hideRequiredAsterisk,
        "show-message": e.showMessage,
        "inline-message": e.inlineMessage,
        "status-icon": e.statusIcon
      }, i.$attrs, { onValidate: t }), {
        default: w(() => [
          E(i.$slots, "default", {}, void 0, !0)
        ]),
        _: 3
      }, 16, ["model", "rules", "label-position", "label-width", "size", "disabled", "validate-on-rule-change", "hide-required-asterisk", "show-message", "inline-message", "status-icon"]);
    };
  }
}), Qe = /* @__PURE__ */ S(Je, [["__scopeId", "data-v-fa9c3c5e"]]), Xe = /* @__PURE__ */ y({
  __name: "Layout",
  props: {
    type: { default: "card" }
  },
  setup(e) {
    const o = e, a = $(() => {
      const { type: l, ...t } = o;
      return t;
    }), n = $(() => [
      "element-plus-layout",
      `element-plus-layout--${o.type}`
    ]);
    return (l, t) => {
      const s = F("el-row"), d = F("el-tabs"), B = F("el-collapse"), v = F("el-card");
      return e.type === "grid" ? (r(), f(s, g({ key: 0 }, a.value, { class: n.value }), {
        default: w(() => [
          E(l.$slots, "default", {}, void 0, !0)
        ]),
        _: 3
      }, 16, ["class"])) : e.type === "tabs" ? (r(), f(d, g({ key: 1 }, a.value, { class: n.value }), {
        default: w(() => [
          E(l.$slots, "default", {}, void 0, !0)
        ]),
        _: 3
      }, 16, ["class"])) : e.type === "collapse" ? (r(), f(B, g({ key: 2 }, a.value, { class: n.value }), {
        default: w(() => [
          E(l.$slots, "default", {}, void 0, !0)
        ]),
        _: 3
      }, 16, ["class"])) : e.type === "card" ? (r(), f(v, g({ key: 3 }, a.value, { class: n.value }), {
        default: w(() => [
          E(l.$slots, "default", {}, void 0, !0)
        ]),
        _: 3
      }, 16, ["class"])) : (r(), p("div", {
        key: 4,
        class: Y(n.value)
      }, [
        E(l.$slots, "default", {}, void 0, !0)
      ], 2));
    };
  }
}), Ze = /* @__PURE__ */ S(Xe, [["__scopeId", "data-v-957d17a8"]]), _e = {
  key: 0,
  class: "element-plus-list__header"
}, et = {
  key: 0,
  class: "element-plus-list__title"
}, tt = { class: "element-plus-list__body" }, at = {
  key: 0,
  class: "element-plus-list__item-count"
}, lt = { class: "element-plus-list__item-index" }, ot = { class: "element-plus-list__item-content" }, nt = {
  key: 0,
  class: "element-plus-list__item-actions"
}, rt = ["onClick"], st = ["onClick"], it = ["onClick"], dt = {
  key: 1,
  class: "element-plus-list__empty"
}, ct = { class: "element-plus-list__empty-text" }, ut = /* @__PURE__ */ y({
  __name: "List",
  props: {
    rows: {},
    title: {},
    bordered: { type: Boolean, default: !0 },
    showActions: { type: Boolean, default: !0 },
    maxRows: {},
    minRows: { default: 0 },
    emptyText: { default: "暂无数据" }
  },
  emits: ["add", "remove", "move"],
  setup(e, { emit: o }) {
    const a = e, n = o, l = $(() => a.maxRows === void 0 ? !0 : a.rows.length < a.maxRows), t = $(() => a.rows.length > (a.minRows ?? 0)), s = (i) => i > 0, d = (i) => i < a.rows.length - 1, B = () => n("add"), v = (i) => n("remove", i), k = (i, m) => n("move", i, m);
    return (i, m) => (r(), p("div", {
      class: Y(["element-plus-list", { bordered: e.bordered }])
    }, [
      e.title || e.showActions ? (r(), p("div", _e, [
        e.title ? (r(), p("h4", et, T(e.title), 1)) : x("", !0),
        e.showActions && l.value ? (r(), p("button", {
          key: 1,
          type: "button",
          class: "element-plus-list__btn element-plus-list__add-btn",
          onClick: B
        }, " + 添加 ")) : x("", !0)
      ])) : x("", !0),
      P("div", tt, [
        e.rows.length > 0 ? (r(), p("div", at, " 共 " + T(e.rows.length) + " 项 ", 1)) : x("", !0),
        (r(!0), p(M, null, A(e.rows, (u, c) => (r(), p("div", {
          key: u.__key || c,
          class: "element-plus-list__item"
        }, [
          P("div", lt, T(c + 1), 1),
          P("div", ot, [
            E(i.$slots, "default", {
              row: u,
              index: c
            }, void 0, !0)
          ]),
          e.showActions ? (r(), p("div", nt, [
            s(c) ? (r(), p("button", {
              key: 0,
              type: "button",
              class: "element-plus-list__btn element-plus-list__btn-icon",
              title: "上移",
              onClick: (z) => k(c, c - 1)
            }, " ↑ ", 8, rt)) : x("", !0),
            d(c) ? (r(), p("button", {
              key: 1,
              type: "button",
              class: "element-plus-list__btn element-plus-list__btn-icon",
              title: "下移",
              onClick: (z) => k(c, c + 1)
            }, " ↓ ", 8, st)) : x("", !0),
            t.value ? (r(), p("button", {
              key: 2,
              type: "button",
              class: "element-plus-list__btn element-plus-list__btn-danger",
              onClick: (z) => v(c)
            }, " 删除 ", 8, it)) : x("", !0)
          ])) : x("", !0)
        ]))), 128)),
        e.rows.length === 0 ? (r(), p("div", dt, [
          P("span", ct, T(e.emptyText), 1),
          e.showActions && l.value ? (r(), p("button", {
            key: 0,
            type: "button",
            class: "element-plus-list__btn element-plus-list__add-btn",
            onClick: B
          }, " + 添加第一项 ")) : x("", !0)
        ])) : x("", !0)
      ])
    ], 2));
  }
}), mt = /* @__PURE__ */ S(ut, [["__scopeId", "data-v-c26597b5"]]), ft = { class: "el-form-item__error-custom" }, ht = /* @__PURE__ */ y({
  __name: "FieldWrapper",
  props: {
    label: {},
    name: {},
    required: { type: Boolean },
    error: {},
    showMessage: { type: Boolean, default: !0 },
    inlineMessage: { type: Boolean, default: !1 },
    size: { default: "default" },
    rules: { default: () => [] },
    showCustomError: { type: Boolean, default: !1 }
  },
  setup(e) {
    const o = e, a = $(() => o.rules && o.rules.length > 0 ? o.rules : void 0);
    return (n, l) => (r(), f(h(he), g({
      label: e.label,
      prop: e.name,
      required: e.required,
      rules: a.value,
      error: e.error,
      "show-message": e.showMessage,
      "inline-message": e.inlineMessage,
      size: e.size
    }, n.$attrs), X({
      default: w(() => [
        E(n.$slots, "default", {}, void 0, !0)
      ]),
      _: 2
    }, [
      e.error && e.showCustomError ? {
        name: "error",
        fn: w(({ error: t }) => [
          P("div", ft, T(t), 1)
        ]),
        key: "0"
      } : void 0
    ]), 1040, ["label", "prop", "required", "rules", "error", "show-message", "inline-message", "size"]));
  }
}), pt = /* @__PURE__ */ S(ht, [["__scopeId", "data-v-2b8940e7"]]), gt = [
  {
    name: "input",
    component: Fe,
    type: "field",
    needFormItem: !0,
    defaultProps: {
      clearable: !0,
      placeholder: "请输入"
    },
    valueTransformer: C("input"),
    eventMapping: b("input")
  },
  {
    name: "textarea",
    component: De,
    type: "field",
    needFormItem: !0,
    defaultProps: {
      rows: 3,
      showWordLimit: !1,
      placeholder: "请输入"
    },
    valueTransformer: C("textarea"),
    eventMapping: b("textarea")
  },
  {
    name: "number",
    component: $e,
    type: "field",
    needFormItem: !0,
    defaultProps: {
      controls: !0,
      controlsPosition: "right"
    },
    valueTransformer: C("number"),
    eventMapping: b("number")
  },
  {
    name: "switch",
    component: Se,
    type: "field",
    needFormItem: !0,
    defaultProps: {
      activeValue: !0,
      inactiveValue: !1
    },
    valueTransformer: C("switch"),
    eventMapping: b("switch")
  },
  {
    name: "checkbox-group",
    component: Ve,
    type: "field",
    needFormItem: !0,
    defaultProps: {
      options: []
    },
    valueTransformer: C("checkbox-group"),
    eventMapping: b("checkbox-group")
  },
  {
    name: "radio-group",
    component: Ae,
    type: "field",
    needFormItem: !0,
    defaultProps: {
      options: []
    },
    valueTransformer: C("radio-group"),
    eventMapping: b("radio-group")
  },
  {
    name: "select",
    component: Re,
    type: "field",
    needFormItem: !0,
    defaultProps: {
      clearable: !0,
      filterable: !0,
      options: []
    },
    valueTransformer: C("select"),
    eventMapping: b("select")
  },
  {
    name: "cascader",
    component: Ne,
    type: "field",
    needFormItem: !0,
    defaultProps: {
      clearable: !0,
      filterable: !1,
      showAllLevels: !0,
      options: []
    },
    valueTransformer: C("cascader"),
    eventMapping: b("cascader")
  },
  {
    name: "date-picker",
    component: Ue,
    type: "field",
    needFormItem: !0,
    defaultProps: {
      type: "date",
      clearable: !0,
      format: "YYYY-MM-DD",
      valueFormat: "YYYY-MM-DD"
    },
    valueTransformer: C("date-picker"),
    eventMapping: b("date-picker")
  },
  {
    name: "time-picker",
    component: Le,
    type: "field",
    needFormItem: !0,
    defaultProps: {
      clearable: !0,
      format: "HH:mm:ss",
      valueFormat: "HH:mm:ss"
    },
    valueTransformer: C("time-picker"),
    eventMapping: b("time-picker")
  },
  {
    name: "slider",
    component: Oe,
    type: "field",
    needFormItem: !0,
    defaultProps: {
      min: 0,
      max: 100,
      step: 1,
      showInput: !1
    },
    valueTransformer: C("slider"),
    eventMapping: b("slider")
  },
  {
    name: "rate",
    component: qe,
    type: "field",
    needFormItem: !0,
    defaultProps: {
      max: 5,
      allowHalf: !1
    },
    valueTransformer: C("rate"),
    eventMapping: b("rate")
  },
  {
    name: "color-picker",
    component: He,
    type: "field",
    needFormItem: !0,
    defaultProps: {
      showAlpha: !1,
      colorFormat: "hex"
    },
    valueTransformer: C("color-picker"),
    eventMapping: b("color-picker")
  },
  {
    name: "upload",
    component: Ke,
    type: "field",
    needFormItem: !0,
    defaultProps: {
      action: "",
      listType: "text",
      autoUpload: !0,
      showFileList: !0
    },
    valueTransformer: C("upload"),
    eventMapping: b("upload")
  }
], vt = [
  {
    name: "form",
    component: Qe,
    type: "form",
    needFormItem: !1,
    defaultProps: {
      labelPosition: "right",
      labelWidth: "100px",
      size: "default"
    },
    eventMapping: b("form")
  },
  {
    name: "layout",
    component: Ze,
    type: "layout",
    needFormItem: !1,
    defaultProps: {
      type: "card",
      shadow: "always"
    },
    eventMapping: b("layout")
  },
  {
    name: "list",
    component: mt,
    type: "list",
    needFormItem: !1,
    defaultProps: {
      sortable: !0,
      showHeader: !0,
      size: "default"
    },
    eventMapping: b("list")
  }
], yt = [
  ...gt,
  ...vt
], bt = {
  name: "@form-renderer/preset-element-plus",
  components: yt,
  // theme: {
  //   size: 'default',
  //   classPrefix: 'el-'
  // },
  setup: async () => {
  },
  formItem: pt,
  ruleConverter: K
};
function zt(e) {
  return {
    ...bt,
    // theme: {
    //   ...ElementPlusPreset.theme,
    //   ...options?.theme
    // },
    ruleConverter: K
  };
}
export {
  Ne as Cascader,
  Ve as CheckboxGroup,
  He as ColorPicker,
  Ue as DatePicker,
  bt as ElementPlusPreset,
  bt as ElementPlusPresetDefault,
  kt as EventMappingUtils,
  pt as FieldWrapper,
  Qe as Form,
  Fe as Input,
  $e as InputNumber,
  Ze as Layout,
  mt as List,
  Ae as RadioGroup,
  qe as Rate,
  Re as Select,
  Oe as Slider,
  Se as Switch,
  De as Textarea,
  Le as TimePicker,
  Ke as Upload,
  ze as cascaderEventMapping,
  Me as colorPickerEventMapping,
  I as commonFieldEventMapping,
  K as convertToElementPlusRules,
  zt as createElementPlusPreset,
  Tt as createEventMapping,
  N as datePickerEventMapping,
  Be as formEventMapping,
  b as getDefaultEventMapping,
  W as inputEventMapping,
  ke as layoutEventMapping,
  Te as listEventMapping,
  Ce as numberEventMapping,
  Pe as rateEventMapping,
  D as selectEventMapping,
  Ee as sliderEventMapping,
  xe as switchEventMapping,
  Ie as uploadEventMapping
};