fec-dev-designer 1.0.0

package/es/node_modules/element-plus/es/components/input-tag/src/composables/use-input-tag-dom.js

@@ -0,0 +1,70 @@
+import { useAttrs as D, useSlots as K, ref as g, computed as n, reactive as U } from "vue";
+import { useResizeObserver as p } from "../../../../../../@vueuse/core/index.js";
+import { useNamespace as f } from "../../../../hooks/use-namespace/index.js";
+import { MINIMUM_INPUT_WIDTH as z } from "../../../../constants/form.js";
+function H({
+  props: l,
+  isFocused: r,
+  hovering: u,
+  disabled: c,
+  inputValue: W,
+  size: I,
+  validateState: x,
+  validateIcon: w,
+  needStatusIcon: b
+}) {
+  const d = D(), m = K(), e = f("input-tag"), y = f("input"), o = g(), a = g(), S = n(() => [
+    e.b(),
+    e.is("focused", r.value),
+    e.is("hovering", u.value),
+    e.is("disabled", c.value),
+    e.m(I.value),
+    e.e("wrapper"),
+    d.class
+  ]), C = n(() => [d.style]), N = n(() => {
+    var t, i;
+    return [
+      e.e("inner"),
+      e.is("draggable", l.draggable),
+      e.is("left-space", !((t = l.modelValue) != null && t.length) && !m.prefix),
+      e.is("right-space", !((i = l.modelValue) != null && i.length) && !h.value)
+    ];
+  }), v = n(() => {
+    var t;
+    return l.clearable && !c.value && !l.readonly && (((t = l.modelValue) == null ? void 0 : t.length) || W.value) && (r.value || u.value);
+  }), h = n(() => m.suffix || v.value || x.value && w.value && b.value), s = U({
+    innerWidth: 0,
+    collapseItemWidth: 0
+  }), T = () => {
+    if (!a.value)
+      return 0;
+    const t = window.getComputedStyle(a.value);
+    return Number.parseFloat(t.gap || "6px");
+  }, _ = () => {
+    s.innerWidth = Number.parseFloat(
+      window.getComputedStyle(a.value).width
+    );
+  }, M = () => {
+    s.collapseItemWidth = o.value.getBoundingClientRect().width;
+  }, R = n(() => {
+    if (!l.collapseTags)
+      return {};
+    const t = T(), i = t + z, V = o.value && l.maxCollapseTags === 1 ? s.innerWidth - s.collapseItemWidth - t - i : s.innerWidth - i;
+    return { maxWidth: `${Math.max(V, 0)}px` };
+  });
+  return p(a, _), p(o, M), {
+    ns: e,
+    nsInput: y,
+    containerKls: S,
+    containerStyle: C,
+    innerKls: N,
+    showClear: v,
+    showSuffix: h,
+    tagStyle: R,
+    collapseItemRef: o,
+    innerRef: a
+  };
+}
+export {
+  H as useInputTagDom
+};

package/es/node_modules/element-plus/es/components/input-tag/src/composables/use-input-tag.js

@@ -0,0 +1,145 @@
+import { shallowRef as q, ref as N, computed as s, watch as J } from "vue";
+import { isAndroid as Q } from "../../../../utils/browser.js";
+import { useFormDisabled as X, useFormSize as Y } from "../../../form/src/hooks/use-form-common-props.js";
+import { isUndefined as Z } from "../../../../utils/types.js";
+import { useFocusController as $ } from "../../../../hooks/use-focus-controller/index.js";
+import { debugWarn as P } from "../../../../utils/error.js";
+import { useComposition as p } from "../../../../hooks/use-composition/index.js";
+import { CHANGE_EVENT as d, INPUT_EVENT as I, UPDATE_MODEL_EVENT as g } from "../../../../constants/event.js";
+import { getEventCode as k } from "../../../../utils/dom/event.js";
+import { EVENT_CODE as v } from "../../../../constants/aria.js";
+import aa from "../../../../../../lodash-es/castArray.js";
+function va({ props: e, emit: t, formItem: r }) {
+  const h = X(), E = Y(), f = q(), n = N(), T = N(), A = s(() => ["small"].includes(E.value) ? "small" : "default"), F = s(() => {
+    var a;
+    return (a = e.modelValue) != null && a.length ? void 0 : e.placeholder;
+  }), R = s(() => !(e.readonly || h.value)), _ = s(() => {
+    var a, l;
+    return Z(e.max) ? !1 : ((l = (a = e.modelValue) == null ? void 0 : a.length) != null ? l : 0) >= e.max;
+  }), L = s(() => {
+    var a;
+    return e.collapseTags ? (a = e.modelValue) == null ? void 0 : a.slice(0, e.maxCollapseTags) : e.modelValue;
+  }), U = s(() => {
+    var a;
+    return e.collapseTags ? (a = e.modelValue) == null ? void 0 : a.slice(e.maxCollapseTags) : [];
+  }), V = (a) => {
+    var l;
+    const o = [...(l = e.modelValue) != null ? l : [], ...aa(a)];
+    t(g, o), t(d, o), t("add-tag", a), n.value = void 0;
+  }, y = (a) => {
+    var l, o;
+    const u = a.split(e.delimiter).filter((i) => i && i !== a);
+    if (e.max) {
+      const i = e.max - ((o = (l = e.modelValue) == null ? void 0 : l.length) != null ? o : 0);
+      u.splice(i);
+    }
+    return u.length === 1 ? u[0] : u;
+  }, b = (a) => {
+    if (_.value) {
+      n.value = void 0;
+      return;
+    }
+    if (!m.value) {
+      if (e.delimiter && n.value) {
+        const l = y(n.value);
+        l.length && V(l);
+      }
+      t(I, a.target.value);
+    }
+  }, z = (a) => {
+    var l;
+    if (m.value)
+      return;
+    switch (k(a)) {
+      case e.trigger:
+        a.preventDefault(), a.stopPropagation(), c();
+        break;
+      case v.numpadEnter:
+        e.trigger === v.enter && (a.preventDefault(), a.stopPropagation(), c());
+        break;
+      case v.backspace:
+        !n.value && ((l = e.modelValue) != null && l.length) && (a.preventDefault(), a.stopPropagation(), C(e.modelValue.length - 1));
+        break;
+    }
+  }, B = (a) => {
+    if (m.value || !Q())
+      return;
+    switch (k(a)) {
+      case v.space:
+        e.trigger === v.space && (a.preventDefault(), a.stopPropagation(), c());
+        break;
+    }
+  }, c = () => {
+    var a;
+    const l = (a = n.value) == null ? void 0 : a.trim();
+    !l || _.value || V(l);
+  }, C = (a) => {
+    var l;
+    const o = ((l = e.modelValue) != null ? l : []).slice(), [u] = o.splice(a, 1);
+    t(g, o), t(d, o), t("remove-tag", u, a);
+  }, O = () => {
+    n.value = void 0, t(g, void 0), t(d, void 0), t("clear");
+  }, S = (a, l, o) => {
+    var u;
+    const i = ((u = e.modelValue) != null ? u : []).slice(), [D] = i.splice(a, 1), w = l > a && o === "before" ? -1 : l < a && o === "after" ? 1 : 0;
+    i.splice(l + w, 0, D), t(g, i), t(d, i), t("drag-tag", a, l + w, D);
+  }, K = () => {
+    var a;
+    (a = f.value) == null || a.focus();
+  }, x = () => {
+    var a;
+    (a = f.value) == null || a.blur();
+  }, { wrapperRef: G, isFocused: H } = $(f, {
+    disabled: h,
+    beforeBlur(a) {
+      var l;
+      return (l = T.value) == null ? void 0 : l.isFocusInsideContent(a);
+    },
+    afterBlur() {
+      var a;
+      e.saveOnBlur ? c() : n.value = void 0, e.validateEvent && ((a = r == null ? void 0 : r.validate) == null || a.call(r, "blur").catch((l) => P(l)));
+    }
+  }), {
+    isComposing: m,
+    handleCompositionStart: M,
+    handleCompositionUpdate: W,
+    handleCompositionEnd: j
+  } = p({ afterComposition: b });
+  return J(
+    () => e.modelValue,
+    () => {
+      var a;
+      e.validateEvent && ((a = r == null ? void 0 : r.validate) == null || a.call(r, d).catch((l) => P(l)));
+    }
+  ), {
+    inputRef: f,
+    wrapperRef: G,
+    tagTooltipRef: T,
+    isFocused: H,
+    isComposing: m,
+    inputValue: n,
+    size: E,
+    tagSize: A,
+    placeholder: F,
+    closable: R,
+    disabled: h,
+    inputLimit: _,
+    showTagList: L,
+    collapseTagList: U,
+    handleDragged: S,
+    handleInput: b,
+    handleKeydown: z,
+    handleKeyup: B,
+    handleAddTag: c,
+    handleRemoveTag: C,
+    handleClear: O,
+    handleCompositionStart: M,
+    handleCompositionUpdate: W,
+    handleCompositionEnd: j,
+    focus: K,
+    blur: x
+  };
+}
+export {
+  va as useInputTag
+};

package/es/node_modules/element-plus/es/components/input-tag/src/input-tag.js

@@ -0,0 +1,86 @@
+import { tagProps as l } from "../../tag/src/tag2.js";
+import { CircleClose as f } from "../../../../../@element-plus/icons-vue/dist/index.js";
+import { buildProps as m, definePropType as r } from "../../../utils/vue/props/runtime.js";
+import { EVENT_CODE as d } from "../../../constants/aria.js";
+import { useSizeProp as u } from "../../../hooks/use-size/index.js";
+import { iconPropType as g } from "../../../utils/vue/icon.js";
+import { UPDATE_MODEL_EVENT as s, CHANGE_EVENT as c, INPUT_EVENT as y } from "../../../constants/event.js";
+import { isArray as a, isString as t } from "../../../../../@vue/shared/dist/shared.esm-bundler.js";
+import { isUndefined as n, isNumber as i } from "../../../utils/types.js";
+const v = m({
+  modelValue: {
+    type: r(Array)
+  },
+  max: Number,
+  tagType: { ...l.type, default: "info" },
+  tagEffect: l.effect,
+  trigger: {
+    type: r(String),
+    default: d.enter
+  },
+  draggable: Boolean,
+  delimiter: {
+    type: [String, RegExp],
+    default: ""
+  },
+  size: u,
+  clearable: Boolean,
+  clearIcon: {
+    type: g,
+    default: f
+  },
+  disabled: {
+    type: Boolean,
+    default: void 0
+  },
+  validateEvent: {
+    type: Boolean,
+    default: !0
+  },
+  readonly: Boolean,
+  autofocus: Boolean,
+  id: {
+    type: String,
+    default: void 0
+  },
+  tabindex: {
+    type: [String, Number],
+    default: 0
+  },
+  maxlength: {
+    type: [String, Number]
+  },
+  minlength: {
+    type: [String, Number]
+  },
+  placeholder: String,
+  autocomplete: {
+    type: r(String),
+    default: "off"
+  },
+  saveOnBlur: {
+    type: Boolean,
+    default: !0
+  },
+  collapseTags: Boolean,
+  collapseTagsTooltip: Boolean,
+  maxCollapseTags: {
+    type: Number,
+    default: 1
+  },
+  ariaLabel: String
+}), C = {
+  [s]: (e) => a(e) || n(e),
+  [c]: (e) => a(e) || n(e),
+  [y]: (e) => t(e),
+  "add-tag": (e) => t(e) || a(e),
+  "remove-tag": (e, o) => t(e) && i(o),
+  "drag-tag": (e, o, p) => i(e) && i(o) && t(p),
+  focus: (e) => e instanceof FocusEvent,
+  blur: (e) => e instanceof FocusEvent,
+  clear: () => !0
+};
+export {
+  C as inputTagEmits,
+  v as inputTagProps
+};

package/es/node_modules/element-plus/es/components/input-tag/src/input-tag2.js

@@ -0,0 +1,322 @@
+import { defineComponent as Se, useSlots as Ee, computed as D, openBlock as l, createElementBlock as g, normalizeClass as n, unref as e, normalizeStyle as U, renderSlot as y, createCommentVNode as v, createElementVNode as i, Fragment as H, renderList as W, createBlock as p, withModifiers as j, withCtx as u, createTextVNode as w, toDisplayString as C, createVNode as ze, withDirectives as q, mergeProps as Ve, isRef as Me, vModelText as Le, vShow as Ke, resolveDynamicComponent as G } from "vue";
+import { ElTooltip as $e } from "../../tooltip/index.js";
+import { ElIcon as J } from "../../icon/index.js";
+import { ElTag as R } from "../../tag/index.js";
+import { inputTagProps as Ne, inputTagEmits as Fe } from "./input-tag.js";
+import Be from "../../../_virtual/plugin-vue_export-helper.js";
+import { useInputTag as Oe } from "./composables/use-input-tag.js";
+import { useHovering as Pe } from "./composables/use-hovering.js";
+import { useDragTag as Ae } from "./composables/use-drag-tag.js";
+import { useInputTagDom as Ue } from "./composables/use-input-tag-dom.js";
+import { useAttrs as He } from "../../../hooks/use-attrs/index.js";
+import { useFormItem as We, useFormItemInputId as je } from "../../form/src/hooks/use-form-item.js";
+import { ValidateComponentsMap as qe } from "../../../utils/vue/icon.js";
+import { useCalcInputWidth as Ge } from "../../../hooks/use-calc-input-width/index.js";
+import { NOOP as Je } from "../../../../../@vue/shared/dist/shared.esm-bundler.js";
+const Qe = ["id", "minlength", "maxlength", "disabled", "readonly", "autocomplete", "tabindex", "placeholder", "autofocus", "ariaLabel"], Xe = ["textContent"], Ye = Se({
+  name: "ElInputTag",
+  inheritAttrs: !1,
+  __name: "input-tag",
+  props: Ne,
+  emits: Fe,
+  setup(Q, { expose: X, emit: Y }) {
+    const b = Q, Z = Y, x = He(), _ = Ee(), { form: S, formItem: c } = We(), { inputId: ee } = je(b, { formItemContext: c }), E = D(() => {
+      var t;
+      return (t = S == null ? void 0 : S.statusIcon) != null ? t : !1;
+    }), f = D(() => (c == null ? void 0 : c.validateState) || ""), I = D(() => f.value && qe[f.value]), {
+      inputRef: te,
+      wrapperRef: z,
+      tagTooltipRef: oe,
+      isFocused: ae,
+      inputValue: d,
+      size: le,
+      tagSize: T,
+      placeholder: ne,
+      closable: h,
+      disabled: V,
+      showTagList: se,
+      collapseTagList: re,
+      handleDragged: ie,
+      handleInput: M,
+      handleKeydown: L,
+      handleKeyup: K,
+      handleRemoveTag: $,
+      handleClear: pe,
+      handleCompositionStart: N,
+      handleCompositionUpdate: F,
+      handleCompositionEnd: B,
+      focus: O,
+      blur: ue
+    } = Oe({ props: b, emit: Z, formItem: c }), { hovering: fe, handleMouseEnter: P, handleMouseLeave: A } = Pe(), { calculatorRef: de, inputStyle: me } = Ge(), {
+      dropIndicatorRef: ge,
+      showDropIndicator: ve,
+      handleDragStart: ce,
+      handleDragOver: ye,
+      handleDragEnd: Ce
+    } = Ae({ wrapperRef: z, handleDragged: ie, afterDragged: O }), {
+      ns: s,
+      nsInput: k,
+      containerKls: be,
+      containerStyle: Ie,
+      innerKls: Te,
+      showClear: he,
+      showSuffix: ke,
+      tagStyle: De,
+      collapseItemRef: we,
+      innerRef: Re
+    } = Ue({
+      props: b,
+      hovering: fe,
+      isFocused: ae,
+      inputValue: d,
+      disabled: V,
+      size: le,
+      validateState: f,
+      validateIcon: I,
+      needStatusIcon: E
+    });
+    return X({
+      focus: O,
+      blur: ue
+    }), (t, a) => (l(), g(
+      "div",
+      {
+        ref_key: "wrapperRef",
+        ref: z,
+        class: n(e(be)),
+        style: U(e(Ie)),
+        onMouseenter: a[8] || (a[8] = (...o) => e(P) && e(P)(...o)),
+        onMouseleave: a[9] || (a[9] = (...o) => e(A) && e(A)(...o))
+      },
+      [
+        e(_).prefix ? (l(), g(
+          "div",
+          {
+            key: 0,
+            class: n(e(s).e("prefix"))
+          },
+          [
+            y(t.$slots, "prefix")
+          ],
+          2
+        )) : v("v-if", !0),
+        i(
+          "div",
+          {
+            ref_key: "innerRef",
+            ref: Re,
+            class: n(e(Te))
+          },
+          [
+            (l(!0), g(
+              H,
+              null,
+              W(e(se), (o, r) => (l(), p(e(R), {
+                key: r,
+                size: e(T),
+                closable: e(h),
+                type: t.tagType,
+                effect: t.tagEffect,
+                draggable: e(h) && t.draggable,
+                style: U(e(De)),
+                "disable-transitions": "",
+                onClose: (m) => e($)(r),
+                onDragstart: (m) => e(ce)(m, r),
+                onDragover: (m) => e(ye)(m, r),
+                onDragend: e(Ce),
+                onDrop: a[0] || (a[0] = j(() => {
+                }, ["stop"]))
+              }, {
+                default: u(() => [
+                  y(t.$slots, "tag", {
+                    value: o,
+                    index: r
+                  }, () => [
+                    w(
+                      C(o),
+                      1
+                    )
+                  ])
+                ]),
+                _: 2
+              }, 1032, ["size", "closable", "type", "effect", "draggable", "style", "onClose", "onDragstart", "onDragover", "onDragend"]))),
+              128
+            )),
+            t.collapseTags && t.modelValue && t.modelValue.length > t.maxCollapseTags ? (l(), p(e($e), {
+              key: 0,
+              ref_key: "tagTooltipRef",
+              ref: oe,
+              disabled: !t.collapseTagsTooltip,
+              "fallback-placements": ["bottom", "top", "right", "left"],
+              effect: t.tagEffect,
+              placement: "bottom"
+            }, {
+              default: u(() => [
+                i(
+                  "div",
+                  {
+                    ref_key: "collapseItemRef",
+                    ref: we
+                  },
+                  [
+                    ze(e(R), {
+                      closable: !1,
+                      size: e(T),
+                      type: t.tagType,
+                      effect: t.tagEffect,
+                      "disable-transitions": ""
+                    }, {
+                      default: u(() => [
+                        w(
+                          " + " + C(t.modelValue.length - t.maxCollapseTags),
+                          1
+                        )
+                      ]),
+                      _: 1
+                    }, 8, ["size", "type", "effect"])
+                  ],
+                  512
+                )
+              ]),
+              content: u(() => [
+                i(
+                  "div",
+                  {
+                    class: n(e(s).e("input-tag-list"))
+                  },
+                  [
+                    (l(!0), g(
+                      H,
+                      null,
+                      W(e(re), (o, r) => (l(), p(e(R), {
+                        key: r,
+                        size: e(T),
+                        closable: e(h),
+                        type: t.tagType,
+                        effect: t.tagEffect,
+                        "disable-transitions": "",
+                        onClose: (m) => e($)(r + t.maxCollapseTags)
+                      }, {
+                        default: u(() => [
+                          y(t.$slots, "tag", {
+                            value: o,
+                            index: r + t.maxCollapseTags
+                          }, () => [
+                            w(
+                              C(o),
+                              1
+                            )
+                          ])
+                        ]),
+                        _: 2
+                      }, 1032, ["size", "closable", "type", "effect", "onClose"]))),
+                      128
+                    ))
+                  ],
+                  2
+                )
+              ]),
+              _: 3
+            }, 8, ["disabled", "effect"])) : v("v-if", !0),
+            i(
+              "div",
+              {
+                class: n(e(s).e("input-wrapper"))
+              },
+              [
+                q(i("input", Ve({
+                  id: e(ee),
+                  ref_key: "inputRef",
+                  ref: te,
+                  "onUpdate:modelValue": a[1] || (a[1] = (o) => Me(d) ? d.value = o : null)
+                }, e(x), {
+                  type: "text",
+                  minlength: t.minlength,
+                  maxlength: t.maxlength,
+                  disabled: e(V),
+                  readonly: t.readonly,
+                  autocomplete: t.autocomplete,
+                  tabindex: t.tabindex,
+                  placeholder: e(ne),
+                  autofocus: t.autofocus,
+                  ariaLabel: t.ariaLabel,
+                  class: e(s).e("input"),
+                  style: e(me),
+                  onCompositionstart: a[2] || (a[2] = (...o) => e(N) && e(N)(...o)),
+                  onCompositionupdate: a[3] || (a[3] = (...o) => e(F) && e(F)(...o)),
+                  onCompositionend: a[4] || (a[4] = (...o) => e(B) && e(B)(...o)),
+                  onInput: a[5] || (a[5] = (...o) => e(M) && e(M)(...o)),
+                  onKeydown: a[6] || (a[6] = (...o) => e(L) && e(L)(...o)),
+                  onKeyup: a[7] || (a[7] = (...o) => e(K) && e(K)(...o))
+                }), null, 16, Qe), [
+                  [Le, e(d)]
+                ]),
+                i("span", {
+                  ref_key: "calculatorRef",
+                  ref: de,
+                  "aria-hidden": "true",
+                  class: n(e(s).e("input-calculator")),
+                  textContent: C(e(d))
+                }, null, 10, Xe)
+              ],
+              2
+            ),
+            q(i(
+              "div",
+              {
+                ref_key: "dropIndicatorRef",
+                ref: ge,
+                class: n(e(s).e("drop-indicator"))
+              },
+              null,
+              2
+            ), [
+              [Ke, e(ve)]
+            ])
+          ],
+          2
+        ),
+        e(ke) ? (l(), g(
+          "div",
+          {
+            key: 1,
+            class: n(e(s).e("suffix"))
+          },
+          [
+            y(t.$slots, "suffix"),
+            e(he) ? (l(), p(e(J), {
+              key: 0,
+              class: n([e(s).e("icon"), e(s).e("clear")]),
+              onMousedown: j(e(Je), ["prevent"]),
+              onClick: e(pe)
+            }, {
+              default: u(() => [
+                (l(), p(G(t.clearIcon)))
+              ]),
+              _: 1
+            }, 8, ["class", "onMousedown", "onClick"])) : v("v-if", !0),
+            f.value && I.value && E.value ? (l(), p(e(J), {
+              key: 1,
+              class: n([
+                e(k).e("icon"),
+                e(k).e("validateIcon"),
+                e(k).is("loading", f.value === "validating")
+              ])
+            }, {
+              default: u(() => [
+                (l(), p(G(I.value)))
+              ]),
+              _: 1
+            }, 8, ["class"])) : v("v-if", !0)
+          ],
+          2
+        )) : v("v-if", !0)
+      ],
+      38
+    ));
+  }
+});
+var dt = /* @__PURE__ */ Be(Ye, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/input-tag/src/input-tag.vue"]]);
+export {
+  dt as default
+};

package/es/node_modules/element-plus/es/components/link/index.js

@@ -0,0 +1,7 @@
+import t from "./src/link2.js";
+import { withInstall as o } from "../../utils/vue/install.js";
+const l = o(t);
+export {
+  l as ElLink,
+  l as default
+};

package/es/node_modules/element-plus/es/components/link/src/link.js

@@ -0,0 +1,29 @@
+import { buildProps as t } from "../../../utils/vue/props/runtime.js";
+import { iconPropType as n } from "../../../utils/vue/icon.js";
+const i = t({
+  type: {
+    type: String,
+    values: ["primary", "success", "warning", "info", "danger", "default"],
+    default: void 0
+  },
+  underline: {
+    type: [Boolean, String],
+    values: [!0, !1, "always", "never", "hover"],
+    default: void 0
+  },
+  disabled: Boolean,
+  href: { type: String, default: "" },
+  target: {
+    type: String,
+    default: "_self"
+  },
+  icon: {
+    type: n
+  }
+}), a = {
+  click: (e) => e instanceof MouseEvent
+};
+export {
+  a as linkEmits,
+  i as linkProps
+};