fec-dev-designer 1.0.0

package/es/node_modules/element-plus/es/components/tooltip/src/content2.js

@@ -0,0 +1,156 @@
+import { defineComponent as Y, ref as T, inject as q, computed as l, onBeforeUnmount as G, unref as o, watch as h, openBlock as y, createBlock as w, withCtx as d, Transition as Q, withDirectives as X, createVNode as Z, mergeProps as x, renderSlot as ee, vShow as oe, createCommentVNode as te } from "vue";
+import { onClickOutside as ne } from "../../../../../@vueuse/core/index.js";
+import { ElTeleport as re } from "../../teleport/index.js";
+import { TOOLTIP_INJECTION_KEY as le } from "./constants.js";
+import { useTooltipContentProps as ae } from "./content.js";
+import { isTriggerType as S } from "./utils.js";
+import se from "../../../_virtual/plugin-vue_export-helper.js";
+import { usePopperContainerId as pe } from "../../../hooks/use-popper-container/index.js";
+import { castArray as ie } from "../../../utils/arrays.js";
+import ue from "../../popper/src/content2.js";
+import { useNamespace as fe } from "../../../hooks/use-namespace/index.js";
+import { focusElement as de } from "../../../utils/dom/aria.js";
+import { composeEventHandlers as k } from "../../../utils/dom/event.js";
+import { computedEager as ce } from "../../../../../@vueuse/shared/index.js";
+const me = Y({
+  name: "ElTooltipContent",
+  inheritAttrs: !1,
+  __name: "content",
+  props: ae,
+  setup(P, { expose: I }) {
+    const n = P, { selector: N } = pe(), R = fe("tooltip"), r = T(), B = ce(() => {
+      var e;
+      return (e = r.value) == null ? void 0 : e.popperContentRef;
+    });
+    let a;
+    const {
+      controlled: c,
+      id: O,
+      open: u,
+      trigger: f,
+      onClose: p,
+      onOpen: A,
+      onShow: H,
+      onHide: L,
+      onBeforeShow: m,
+      onBeforeHide: v
+    } = q(le, void 0), _ = l(() => n.transition || `${R.namespace.value}-fade-in-linear`), g = l(() => process.env.NODE_ENV === "test" && !process.env.RUN_TEST_WITH_PERSISTENT ? !0 : n.persistent);
+    G(() => {
+      a == null || a();
+    });
+    const M = l(() => o(g) ? !0 : o(u)), C = l(() => n.disabled ? !1 : o(u)), z = l(() => n.appendTo || N.value), V = l(() => {
+      var e;
+      return (e = n.style) != null ? e : {};
+    }), i = T(!0), $ = () => {
+      L(), E() && de(document.body, { preventScroll: !0 }), i.value = !0;
+    }, b = () => {
+      if (o(c))
+        return !0;
+    }, D = k(b, () => {
+      n.enterable && S(o(f), "hover") && A();
+    }), U = k(b, () => {
+      S(o(f), "hover") && p();
+    }), W = () => {
+      var e, t;
+      (t = (e = r.value) == null ? void 0 : e.updatePopper) == null || t.call(e), m == null || m();
+    }, j = () => {
+      v == null || v();
+    }, F = () => {
+      H();
+    }, J = () => {
+      n.virtualTriggering || p();
+    }, E = (e) => {
+      var t;
+      const s = (t = r.value) == null ? void 0 : t.popperContentRef, K = (e == null ? void 0 : e.relatedTarget) || document.activeElement;
+      return s == null ? void 0 : s.contains(K);
+    };
+    return h(
+      () => o(u),
+      (e) => {
+        e ? (i.value = !1, a = ne(
+          B,
+          () => {
+            if (o(c))
+              return;
+            ie(o(f)).every((s) => s !== "hover" && s !== "focus") && p();
+          },
+          { detectIframe: !0 }
+        )) : a == null || a();
+      },
+      {
+        flush: "post"
+      }
+    ), h(
+      () => n.content,
+      () => {
+        var e, t;
+        (t = (e = r.value) == null ? void 0 : e.updatePopper) == null || t.call(e);
+      }
+    ), I({
+      contentRef: r,
+      isFocusInsideContent: E
+    }), (e, t) => (y(), w(o(re), {
+      disabled: !e.teleported,
+      to: z.value
+    }, {
+      default: d(() => [
+        M.value || !i.value ? (y(), w(Q, {
+          key: 0,
+          name: _.value,
+          appear: !g.value,
+          onAfterLeave: $,
+          onBeforeEnter: W,
+          onAfterEnter: F,
+          onBeforeLeave: j,
+          persisted: ""
+        }, {
+          default: d(() => [
+            X(Z(o(ue), x({
+              id: o(O),
+              ref_key: "contentRef",
+              ref: r
+            }, e.$attrs, {
+              "aria-label": e.ariaLabel,
+              "aria-hidden": i.value,
+              "boundaries-padding": e.boundariesPadding,
+              "fallback-placements": e.fallbackPlacements,
+              "gpu-acceleration": e.gpuAcceleration,
+              offset: e.offset,
+              placement: e.placement,
+              "popper-options": e.popperOptions,
+              "arrow-offset": e.arrowOffset,
+              strategy: e.strategy,
+              effect: e.effect,
+              enterable: e.enterable,
+              pure: e.pure,
+              "popper-class": e.popperClass,
+              "popper-style": [e.popperStyle, V.value],
+              "reference-el": e.referenceEl,
+              "trigger-target-el": e.triggerTargetEl,
+              visible: C.value,
+              "z-index": e.zIndex,
+              loop: e.loop,
+              onMouseenter: o(D),
+              onMouseleave: o(U),
+              onBlur: J,
+              onClose: o(p)
+            }), {
+              default: d(() => [
+                ee(e.$slots, "default")
+              ]),
+              _: 3
+            }, 16, ["id", "aria-label", "aria-hidden", "boundaries-padding", "fallback-placements", "gpu-acceleration", "offset", "placement", "popper-options", "arrow-offset", "strategy", "effect", "enterable", "pure", "popper-class", "popper-style", "reference-el", "trigger-target-el", "visible", "z-index", "loop", "onMouseenter", "onMouseleave", "onClose"]), [
+              [oe, C.value]
+            ])
+          ]),
+          _: 3
+        }, 8, ["name", "appear"])) : te("v-if", !0)
+      ]),
+      _: 3
+    }, 8, ["disabled", "to"]));
+  }
+});
+var Re = /* @__PURE__ */ se(me, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tooltip/src/content.vue"]]);
+export {
+  Re as default
+};

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

@@ -0,0 +1,36 @@
+import { useTooltipContentProps as o } from "./content.js";
+import { useTooltipTriggerProps as e } from "./trigger.js";
+import { popperProps as r } from "../../popper/src/popper.js";
+import { popperArrowProps as p } from "../../popper/src/arrow.js";
+import { createModelToggleComposable as s } from "../../../hooks/use-model-toggle/index.js";
+import { buildProps as l } from "../../../utils/vue/props/runtime.js";
+const {
+  useModelToggleProps: t,
+  useModelToggleEmits: i,
+  useModelToggle: P
+} = s("visible"), n = l({
+  ...r,
+  ...t,
+  ...o,
+  ...e,
+  ...p,
+  showArrow: {
+    type: Boolean,
+    default: !0
+  }
+}), M = [
+  ...i,
+  "before-show",
+  "before-hide",
+  "show",
+  "hide",
+  "open",
+  "close"
+];
+export {
+  M as tooltipEmits,
+  P as useTooltipModelToggle,
+  i as useTooltipModelToggleEmits,
+  t as useTooltipModelToggleProps,
+  n as useTooltipProps
+};

package/es/node_modules/element-plus/es/components/tooltip/src/tooltip2.js

@@ -0,0 +1,156 @@
+import { defineComponent as S, ref as i, toRef as l, computed as h, provide as L, readonly as z, unref as p, watch as D, onDeactivated as M, onBeforeUnmount as $, openBlock as s, createBlock as b, withCtx as c, createVNode as w, renderSlot as T, createCommentVNode as y, createElementBlock as k, toDisplayString as F } from "vue";
+import { ElPopper as K } from "../../popper/index.js";
+import { TOOLTIP_INJECTION_KEY as U } from "./constants.js";
+import { useTooltipProps as V, tooltipEmits as J, useTooltipModelToggle as Y } from "./tooltip.js";
+import j from "./trigger2.js";
+import q from "./content2.js";
+import G from "../../../_virtual/plugin-vue_export-helper.js";
+import { usePopperContainer as Q } from "../../../hooks/use-popper-container/index.js";
+import { useDelayedToggle as W } from "../../../hooks/use-delayed-toggle/index.js";
+import X from "../../popper/src/arrow2.js";
+import { useNamespace as Z } from "../../../hooks/use-namespace/index.js";
+import { useId as _ } from "../../../hooks/use-id/index.js";
+import { isBoolean as x } from "../../../utils/types.js";
+const ee = ["innerHTML"], oe = { key: 1 }, re = S({
+  name: "ElTooltip",
+  __name: "tooltip",
+  props: V,
+  emits: J,
+  setup(C, { expose: E, emit: A }) {
+    const o = C, a = A;
+    Q();
+    const I = Z("tooltip"), P = _(), f = i(), d = i(), v = () => {
+      var e;
+      const n = p(f);
+      n && ((e = n.popperInstanceRef) == null || e.update());
+    }, r = i(!1), t = i(), { show: R, hide: g, hasUpdateHandler: B } = Y({
+      indicator: r,
+      toggleReason: t
+    }), { onOpen: u, onClose: m } = W({
+      showAfter: l(o, "showAfter"),
+      hideAfter: l(o, "hideAfter"),
+      autoClose: l(o, "autoClose"),
+      open: R,
+      close: g
+    }), O = h(
+      () => x(o.visible) && !B.value
+    ), H = h(() => [I.b(), o.popperClass]);
+    L(U, {
+      controlled: O,
+      id: P,
+      open: z(r),
+      trigger: l(o, "trigger"),
+      onOpen: u,
+      onClose: m,
+      onToggle: (e) => {
+        p(r) ? m(e) : u(e);
+      },
+      onShow: () => {
+        a("show", t.value);
+      },
+      onHide: () => {
+        a("hide", t.value);
+      },
+      onBeforeShow: () => {
+        a("before-show", t.value);
+      },
+      onBeforeHide: () => {
+        a("before-hide", t.value);
+      },
+      updatePopper: v
+    }), D(
+      () => o.disabled,
+      (e) => {
+        e && r.value && (r.value = !1);
+      }
+    );
+    const N = (e) => {
+      var n;
+      return (n = d.value) == null ? void 0 : n.isFocusInsideContent(e);
+    };
+    return M(() => r.value && g()), $(() => {
+      t.value = void 0;
+    }), E({
+      popperRef: f,
+      contentRef: d,
+      isFocusInsideContent: N,
+      updatePopper: v,
+      onOpen: u,
+      onClose: m,
+      hide: g
+    }), (e, n) => (s(), b(p(K), {
+      ref_key: "popperRef",
+      ref: f,
+      role: e.role
+    }, {
+      default: c(() => [
+        w(j, {
+          disabled: e.disabled,
+          trigger: e.trigger,
+          "trigger-keys": e.triggerKeys,
+          "virtual-ref": e.virtualRef,
+          "virtual-triggering": e.virtualTriggering,
+          "focus-on-target": e.focusOnTarget
+        }, {
+          default: c(() => [
+            e.$slots.default ? T(e.$slots, "default", { key: 0 }) : y("v-if", !0)
+          ]),
+          _: 3
+        }, 8, ["disabled", "trigger", "trigger-keys", "virtual-ref", "virtual-triggering", "focus-on-target"]),
+        w(q, {
+          ref_key: "contentRef",
+          ref: d,
+          "aria-label": e.ariaLabel,
+          "boundaries-padding": e.boundariesPadding,
+          content: e.content,
+          disabled: e.disabled,
+          effect: e.effect,
+          enterable: e.enterable,
+          "fallback-placements": e.fallbackPlacements,
+          "hide-after": e.hideAfter,
+          "gpu-acceleration": e.gpuAcceleration,
+          offset: e.offset,
+          persistent: e.persistent,
+          "popper-class": H.value,
+          "popper-style": e.popperStyle,
+          placement: e.placement,
+          "popper-options": e.popperOptions,
+          "arrow-offset": e.arrowOffset,
+          pure: e.pure,
+          "raw-content": e.rawContent,
+          "reference-el": e.referenceEl,
+          "trigger-target-el": e.triggerTargetEl,
+          "show-after": e.showAfter,
+          strategy: e.strategy,
+          teleported: e.teleported,
+          transition: e.transition,
+          "virtual-triggering": e.virtualTriggering,
+          "z-index": e.zIndex,
+          "append-to": e.appendTo,
+          loop: e.loop
+        }, {
+          default: c(() => [
+            T(e.$slots, "content", {}, () => [
+              e.rawContent ? (s(), k("span", {
+                key: 0,
+                innerHTML: e.content
+              }, null, 8, ee)) : (s(), k(
+                "span",
+                oe,
+                F(e.content),
+                1
+              ))
+            ]),
+            e.showArrow ? (s(), b(p(X), { key: 0 })) : y("v-if", !0)
+          ]),
+          _: 3
+        }, 8, ["aria-label", "boundaries-padding", "content", "disabled", "effect", "enterable", "fallback-placements", "hide-after", "gpu-acceleration", "offset", "persistent", "popper-class", "popper-style", "placement", "popper-options", "arrow-offset", "pure", "raw-content", "reference-el", "trigger-target-el", "show-after", "strategy", "teleported", "transition", "virtual-triggering", "z-index", "append-to", "loop"])
+      ]),
+      _: 3
+    }, 8, ["role"]));
+  }
+});
+var ve = /* @__PURE__ */ G(re, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tooltip/src/tooltip.vue"]]);
+export {
+  ve as default
+};

package/es/node_modules/element-plus/es/components/tooltip/src/trigger.js

@@ -0,0 +1,19 @@
+import { popperTriggerProps as o } from "../../popper/src/trigger.js";
+import { buildProps as p, definePropType as e } from "../../../utils/vue/props/runtime.js";
+import { EVENT_CODE as r } from "../../../constants/aria.js";
+const g = p({
+  ...o,
+  disabled: Boolean,
+  trigger: {
+    type: e([String, Array]),
+    default: "hover"
+  },
+  triggerKeys: {
+    type: e(Array),
+    default: () => [r.enter, r.numpadEnter, r.space]
+  },
+  focusOnTarget: Boolean
+});
+export {
+  g as useTooltipTriggerProps
+};

package/es/node_modules/element-plus/es/components/tooltip/src/trigger2.js

@@ -0,0 +1,80 @@
+import { defineComponent as w, inject as O, ref as B, toRef as K, openBlock as y, createBlock as b, unref as o, normalizeClass as D, withCtx as F, renderSlot as I, nextTick as N } from "vue";
+import { TOOLTIP_INJECTION_KEY as P } from "./constants.js";
+import { useTooltipTriggerProps as R } from "./trigger.js";
+import { whenTrigger as s } from "./utils.js";
+import S from "../../../_virtual/plugin-vue_export-helper.js";
+import j from "../../popper/src/trigger2.js";
+import { composeEventHandlers as n, getEventCode as z } from "../../../utils/dom/event.js";
+import { useNamespace as H } from "../../../hooks/use-namespace/index.js";
+import { focusElement as J } from "../../../utils/dom/aria.js";
+const L = w({
+  name: "ElTooltipTrigger",
+  __name: "trigger",
+  props: R,
+  setup(g, { expose: a }) {
+    const i = g, f = H("tooltip"), { controlled: m, id: d, open: v, onOpen: u, onClose: c, onToggle: l } = O(
+      P,
+      void 0
+    ), T = B(null), r = () => {
+      if (o(m) || i.disabled)
+        return !0;
+    }, t = K(i, "trigger"), C = n(
+      r,
+      s(t, "hover", (e) => {
+        u(e), i.focusOnTarget && e.target && N(() => {
+          J(e.target, { preventScroll: !0 });
+        });
+      })
+    ), _ = n(
+      r,
+      s(t, "hover", c)
+    ), k = n(
+      r,
+      s(t, "click", (e) => {
+        e.button === 0 && l(e);
+      })
+    ), E = n(
+      r,
+      s(t, "focus", u)
+    ), h = n(
+      r,
+      s(t, "focus", c)
+    ), x = n(
+      r,
+      s(t, "contextmenu", (e) => {
+        e.preventDefault(), l(e);
+      })
+    ), M = n(
+      r,
+      (e) => {
+        const p = z(e);
+        i.triggerKeys.includes(p) && (e.preventDefault(), l(e));
+      }
+    );
+    return a({
+      triggerRef: T
+    }), (e, p) => (y(), b(o(j), {
+      id: o(d),
+      "virtual-ref": e.virtualRef,
+      open: o(v),
+      "virtual-triggering": e.virtualTriggering,
+      class: D(o(f).e("trigger")),
+      onBlur: o(h),
+      onClick: o(k),
+      onContextmenu: o(x),
+      onFocus: o(E),
+      onMouseenter: o(C),
+      onMouseleave: o(_),
+      onKeydown: o(M)
+    }, {
+      default: F(() => [
+        I(e.$slots, "default")
+      ]),
+      _: 3
+    }, 8, ["id", "virtual-ref", "open", "virtual-triggering", "class", "onBlur", "onClick", "onContextmenu", "onFocus", "onMouseenter", "onMouseleave", "onKeydown"]));
+  }
+});
+var X = /* @__PURE__ */ S(L, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/tooltip/src/trigger.vue"]]);
+export {
+  X as default
+};

package/es/node_modules/element-plus/es/components/tooltip/src/utils.js

@@ -0,0 +1,9 @@
+import { unref as i } from "vue";
+import { isArray as s } from "../../../../../@vue/shared/dist/shared.esm-bundler.js";
+const t = (r, n) => s(r) ? r.includes(n) : r === n, m = (r, n, e) => (o) => {
+  t(i(r), n) && e(o);
+};
+export {
+  t as isTriggerType,
+  m as whenTrigger
+};

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

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