npm - @funcho/ui - Versions diffs - 1.0.0 - Mend

@funcho/ui 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1050) hide show

package/dist/cjs/node_modules/.pnpm/element-plus@2.13.1_patch_hash_ced11f8511a7bfaac0aa406d84db594ed486bf3fc0839b47dbe1220b_eeafcc9acb73a92d66a934304ea2d16a/node_modules/element-plus/es/components/popper/src/composables/use-content.js ADDED Viewed

@@ -0,0 +1,83 @@
+'use strict';
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const vue = require('vue');
+const constants = require('../constants.js');
+const utils = require('../utils.js');
+const index = require('../../../../hooks/use-popper/index.js');
+const isUndefined = require('../../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isUndefined.js');
+const DEFAULT_ARROW_OFFSET = 0;
+const usePopperContent = (props) => {
+  const { popperInstanceRef, contentRef, triggerRef, role } = vue.inject(
+    constants.POPPER_INJECTION_KEY,
+    void 0
+  );
+  const arrowRef = vue.ref();
+  const arrowOffset = vue.computed(() => props.arrowOffset);
+  const eventListenerModifier = vue.computed(() => {
+    return {
+      name: "eventListeners",
+      enabled: !!props.visible
+    };
+  });
+  const arrowModifier = vue.computed(() => {
+    var _a;
+    const arrowEl = vue.unref(arrowRef);
+    const offset = (_a = vue.unref(arrowOffset)) != null ? _a : DEFAULT_ARROW_OFFSET;
+    return {
+      name: "arrow",
+      enabled: !isUndefined.default(arrowEl),
+      options: {
+        element: arrowEl,
+        padding: offset
+      }
+    };
+  });
+  const options = vue.computed(() => {
+    return {
+      onFirstUpdate: () => {
+        update();
+      },
+      ...utils.buildPopperOptions(props, [
+        vue.unref(arrowModifier),
+        vue.unref(eventListenerModifier)
+      ])
+    };
+  });
+  const computedReference = vue.computed(
+    () => utils.unwrapMeasurableEl(props.referenceEl) || vue.unref(triggerRef)
+  );
+  const { attributes, state, styles, update, forceUpdate, instanceRef } = index.usePopper(computedReference, contentRef, options);
+  vue.watch(instanceRef, (instance) => popperInstanceRef.value = instance, {
+    flush: "sync"
+  });
+  vue.onMounted(() => {
+    vue.watch(
+      () => {
+        var _a, _b;
+        return (_b = (_a = vue.unref(computedReference)) == null ? void 0 : _a.getBoundingClientRect) == null ? void 0 : _b.call(_a);
+      },
+      () => {
+        update();
+      }
+    );
+  });
+  vue.onBeforeUnmount(() => {
+    popperInstanceRef.value = void 0;
+  });
+  return {
+    attributes,
+    arrowRef,
+    contentRef,
+    instanceRef,
+    state,
+    styles,
+    role,
+    forceUpdate,
+    update
+  };
+};
+exports.usePopperContent = usePopperContent;

@@ -0,0 +1,54 @@
+'use strict';
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const vue = require('vue');
+const usePopperContentFocusTrap = (props, emit) => {
+  const trapped = vue.ref(false);
+  const focusStartRef = vue.ref();
+  const onFocusAfterTrapped = () => {
+    emit("focus");
+  };
+  const onFocusAfterReleased = (event) => {
+    var _a;
+    if (((_a = event.detail) == null ? void 0 : _a.focusReason) !== "pointer") {
+      focusStartRef.value = "first";
+      emit("blur");
+    }
+  };
+  const onFocusInTrap = (event) => {
+    if (props.visible && !trapped.value) {
+      if (event.target) {
+        focusStartRef.value = event.target;
+      }
+      trapped.value = true;
+    }
+  };
+  const onFocusoutPrevented = (event) => {
+    if (!props.trapping) {
+      if (event.detail.focusReason === "pointer") {
+        event.preventDefault();
+      }
+      trapped.value = false;
+    }
+  };
+  const onReleaseRequested = () => {
+    trapped.value = false;
+    emit("close");
+  };
+  vue.onBeforeUnmount(() => {
+    focusStartRef.value = void 0;
+  });
+  return {
+    focusStartRef,
+    trapped,
+    onFocusAfterReleased,
+    onFocusAfterTrapped,
+    onFocusInTrap,
+    onFocusoutPrevented,
+    onReleaseRequested
+  };
+};
+exports.usePopperContentFocusTrap = usePopperContentFocusTrap;

@@ -0,0 +1,9 @@
+'use strict';
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const POPPER_INJECTION_KEY = Symbol("popper");
+const POPPER_CONTENT_INJECTION_KEY = Symbol("popperContent");
+exports.POPPER_CONTENT_INJECTION_KEY = POPPER_CONTENT_INJECTION_KEY;
+exports.POPPER_INJECTION_KEY = POPPER_INJECTION_KEY;

@@ -0,0 +1,96 @@
+'use strict';
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const index$1 = require('../../../../../../../@sxzz_popperjs-es@2.11.7/node_modules/@sxzz/popperjs-es/dist/index.js');
+const arrow = require('./arrow.js');
+const runtime = require('../../../utils/vue/props/runtime.js');
+const index = require('../../../hooks/use-aria/index.js');
+const POSITIONING_STRATEGIES = ["fixed", "absolute"];
+const popperCoreConfigProps = runtime.buildProps({
+  boundariesPadding: {
+    type: Number,
+    default: 0
+  },
+  fallbackPlacements: {
+    type: runtime.definePropType(Array),
+    default: void 0
+  },
+  gpuAcceleration: {
+    type: Boolean,
+    default: true
+  },
+  offset: {
+    type: Number,
+    default: 12
+  },
+  placement: {
+    type: String,
+    values: index$1.placements,
+    default: "bottom"
+  },
+  popperOptions: {
+    type: runtime.definePropType(Object),
+    default: () => ({})
+  },
+  strategy: {
+    type: String,
+    values: POSITIONING_STRATEGIES,
+    default: "absolute"
+  }
+});
+const popperContentProps = runtime.buildProps({
+  ...popperCoreConfigProps,
+  ...arrow.popperArrowProps,
+  id: String,
+  style: {
+    type: runtime.definePropType([String, Array, Object])
+  },
+  className: {
+    type: runtime.definePropType([String, Array, Object])
+  },
+  effect: {
+    type: runtime.definePropType(String),
+    default: "dark"
+  },
+  visible: Boolean,
+  enterable: {
+    type: Boolean,
+    default: true
+  },
+  pure: Boolean,
+  focusOnShow: Boolean,
+  trapping: Boolean,
+  popperClass: {
+    type: runtime.definePropType([String, Array, Object])
+  },
+  popperStyle: {
+    type: runtime.definePropType([String, Array, Object])
+  },
+  referenceEl: {
+    type: runtime.definePropType(Object)
+  },
+  triggerTargetEl: {
+    type: runtime.definePropType(Object)
+  },
+  stopPopperMouseEvent: {
+    type: Boolean,
+    default: true
+  },
+  virtualTriggering: Boolean,
+  zIndex: Number,
+  ...index.useAriaProps(["ariaLabel"]),
+  loop: Boolean
+});
+const popperContentEmits = {
+  mouseenter: (evt) => evt instanceof MouseEvent,
+  mouseleave: (evt) => evt instanceof MouseEvent,
+  focus: () => true,
+  blur: () => true,
+  close: () => true
+};
+exports.popperContentEmits = popperContentEmits;
+exports.popperContentProps = popperContentProps;
+exports.popperCoreConfigProps = popperCoreConfigProps;

@@ -0,0 +1,154 @@
+'use strict';
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const vue = require('vue');
+const focusTrap = require('../../focus-trap/src/focus-trap.js');
+const constants$1 = require('./constants.js');
+const content = require('./content.js');
+const pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
+const useFocusTrap = require('./composables/use-focus-trap.js');
+const useContent = require('./composables/use-content.js');
+const useContentDom = require('./composables/use-content-dom.js');
+const constants = require('../../form/src/constants.js');
+const shared_esmBundler = require('../../../../../../../@vue_shared@3.5.22/node_modules/@vue/shared/dist/shared.esm-bundler.js');
+const types = require('../../../utils/types.js');
+const isNil = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isNil.js');
+const _sfc_main = vue.defineComponent({
+  ...{
+    name: "ElPopperContent"
+  },
+  __name: "content",
+  props: content.popperContentProps,
+  emits: content.popperContentEmits,
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const emit = __emit;
+    const props = __props;
+    const {
+      focusStartRef,
+      trapped,
+      onFocusAfterReleased,
+      onFocusAfterTrapped,
+      onFocusInTrap,
+      onFocusoutPrevented,
+      onReleaseRequested
+    } = useFocusTrap.usePopperContentFocusTrap(props, emit);
+    const { attributes, arrowRef, contentRef, styles, instanceRef, role, update } = useContent.usePopperContent(props);
+    const {
+      ariaModal,
+      arrowStyle,
+      contentAttrs,
+      contentClass,
+      contentStyle,
+      updateZIndex
+    } = useContentDom.usePopperContentDOM(props, {
+      styles,
+      attributes,
+      role
+    });
+    const formItemContext = vue.inject(constants.formItemContextKey, void 0);
+    vue.provide(constants$1.POPPER_CONTENT_INJECTION_KEY, {
+      arrowStyle,
+      arrowRef
+    });
+    if (formItemContext) {
+      vue.provide(constants.formItemContextKey, {
+        ...formItemContext,
+        addInputId: shared_esmBundler.NOOP,
+        removeInputId: shared_esmBundler.NOOP
+      });
+    }
+    let triggerTargetAriaStopWatch = void 0;
+    const updatePopper = (shouldUpdateZIndex = true) => {
+      update();
+      shouldUpdateZIndex && updateZIndex();
+    };
+    const togglePopperAlive = () => {
+      updatePopper(false);
+      if (props.visible && props.focusOnShow) {
+        trapped.value = true;
+      } else if (props.visible === false) {
+        trapped.value = false;
+      }
+    };
+    vue.onMounted(() => {
+      vue.watch(
+        () => props.triggerTargetEl,
+        (triggerTargetEl, prevTriggerTargetEl) => {
+          triggerTargetAriaStopWatch == null ? void 0 : triggerTargetAriaStopWatch();
+          triggerTargetAriaStopWatch = void 0;
+          const el = vue.unref(triggerTargetEl || contentRef.value);
+          const prevEl = vue.unref(prevTriggerTargetEl || contentRef.value);
+          if (types.isElement(el)) {
+            triggerTargetAriaStopWatch = vue.watch(
+              [role, () => props.ariaLabel, ariaModal, () => props.id],
+              (watches) => {
+                ["role", "aria-label", "aria-modal", "id"].forEach((key, idx) => {
+                  isNil.default(watches[idx]) ? el.removeAttribute(key) : el.setAttribute(key, watches[idx]);
+                });
+              },
+              { immediate: true }
+            );
+          }
+          if (prevEl !== el && types.isElement(prevEl)) {
+            ["role", "aria-label", "aria-modal", "id"].forEach((key) => {
+              prevEl.removeAttribute(key);
+            });
+          }
+        },
+        { immediate: true }
+      );
+      vue.watch(() => props.visible, togglePopperAlive, { immediate: true });
+    });
+    vue.onBeforeUnmount(() => {
+      triggerTargetAriaStopWatch == null ? void 0 : triggerTargetAriaStopWatch();
+      triggerTargetAriaStopWatch = void 0;
+      contentRef.value = void 0;
+    });
+    __expose({
+      popperContentRef: contentRef,
+      popperInstanceRef: instanceRef,
+      updatePopper,
+      contentStyle
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock(
+        "div",
+        vue.mergeProps({
+          ref_key: "contentRef",
+          ref: contentRef
+        }, vue.unref(contentAttrs), {
+          style: vue.unref(contentStyle),
+          class: vue.unref(contentClass),
+          tabindex: "-1",
+          onMouseenter: _cache[0] || (_cache[0] = (e) => _ctx.$emit("mouseenter", e)),
+          onMouseleave: _cache[1] || (_cache[1] = (e) => _ctx.$emit("mouseleave", e))
+        }),
+        [
+          vue.createVNode(vue.unref(focusTrap.default), {
+            loop: _ctx.loop,
+            trapped: vue.unref(trapped),
+            "trap-on-focus-in": true,
+            "focus-trap-el": vue.unref(contentRef),
+            "focus-start-el": vue.unref(focusStartRef),
+            onFocusAfterTrapped: vue.unref(onFocusAfterTrapped),
+            onFocusAfterReleased: vue.unref(onFocusAfterReleased),
+            onFocusin: vue.unref(onFocusInTrap),
+            onFocusoutPrevented: vue.unref(onFocusoutPrevented),
+            onReleaseRequested: vue.unref(onReleaseRequested)
+          }, {
+            default: vue.withCtx(() => [
+              vue.renderSlot(_ctx.$slots, "default")
+            ]),
+            _: 3
+          }, 8, ["loop", "trapped", "focus-trap-el", "focus-start-el", "onFocusAfterTrapped", "onFocusAfterReleased", "onFocusin", "onFocusoutPrevented", "onReleaseRequested"])
+        ],
+        16
+      );
+    };
+  }
+});
+var ElPopperContent = /* @__PURE__ */ pluginVue_exportHelper.default(_sfc_main, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/popper/src/content.vue"]]);
+exports.default = ElPopperContent;

@@ -0,0 +1,26 @@
+'use strict';
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const runtime = require('../../../utils/vue/props/runtime.js');
+const roleTypes = [
+  "dialog",
+  "grid",
+  "group",
+  "listbox",
+  "menu",
+  "navigation",
+  "tooltip",
+  "tree"
+];
+const popperProps = runtime.buildProps({
+  role: {
+    type: String,
+    values: roleTypes,
+    default: "tooltip"
+  }
+});
+exports.popperProps = popperProps;
+exports.roleTypes = roleTypes;

@@ -0,0 +1,40 @@
+'use strict';
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const vue = require('vue');
+const constants = require('./constants.js');
+const popper = require('./popper.js');
+const pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
+const _sfc_main = vue.defineComponent({
+  ...{
+    name: "ElPopper",
+    inheritAttrs: false
+  },
+  __name: "popper",
+  props: popper.popperProps,
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const triggerRef = vue.ref();
+    const popperInstanceRef = vue.ref();
+    const contentRef = vue.ref();
+    const referenceRef = vue.ref();
+    const role = vue.computed(() => props.role);
+    const popperProvides = {
+      triggerRef,
+      popperInstanceRef,
+      contentRef,
+      referenceRef,
+      role
+    };
+    __expose(popperProvides);
+    vue.provide(constants.POPPER_INJECTION_KEY, popperProvides);
+    return (_ctx, _cache) => {
+      return vue.renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+var Popper = /* @__PURE__ */ pluginVue_exportHelper.default(_sfc_main, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/popper/src/popper.vue"]]);
+exports.default = Popper;

@@ -0,0 +1,37 @@
+'use strict';
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const runtime = require('../../../utils/vue/props/runtime.js');
+const popperTriggerProps = runtime.buildProps({
+  virtualRef: {
+    type: runtime.definePropType(Object)
+  },
+  virtualTriggering: Boolean,
+  onMouseenter: {
+    type: runtime.definePropType(Function)
+  },
+  onMouseleave: {
+    type: runtime.definePropType(Function)
+  },
+  onClick: {
+    type: runtime.definePropType(Function)
+  },
+  onKeydown: {
+    type: runtime.definePropType(Function)
+  },
+  onFocus: {
+    type: runtime.definePropType(Function)
+  },
+  onBlur: {
+    type: runtime.definePropType(Function)
+  },
+  onContextmenu: {
+    type: runtime.definePropType(Function)
+  },
+  id: String,
+  open: Boolean
+});
+exports.popperTriggerProps = popperTriggerProps;

@@ -0,0 +1,164 @@
+'use strict';
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+const vue = require('vue');
+const index$1 = require('../../../../../../../@vueuse_core@10.11.1_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/core/index.js');
+const constants = require('./constants.js');
+const trigger = require('./trigger.js');
+const pluginVue_exportHelper = require('../../../_virtual/plugin-vue_export-helper.js');
+const index = require('../../../hooks/use-forward-ref/index.js');
+const onlyChild = require('../../slot/src/only-child.js');
+const types = require('../../../utils/types.js');
+const aria = require('../../../utils/dom/aria.js');
+const isNil = require('../../../../../../../lodash-es@4.17.21/node_modules/lodash-es/isNil.js');
+const _sfc_main = vue.defineComponent({
+  ...{
+    name: "ElPopperTrigger",
+    inheritAttrs: false
+  },
+  __name: "trigger",
+  props: trigger.popperTriggerProps,
+  setup(__props, { expose: __expose }) {
+    const props = __props;
+    const { role, triggerRef } = vue.inject(constants.POPPER_INJECTION_KEY, void 0);
+    index.useForwardRef(triggerRef);
+    const ariaControls = vue.computed(() => {
+      return ariaHaspopup.value ? props.id : void 0;
+    });
+    const ariaDescribedby = vue.computed(() => {
+      if (role && role.value === "tooltip") {
+        return props.open && props.id ? props.id : void 0;
+      }
+      return void 0;
+    });
+    const ariaHaspopup = vue.computed(() => {
+      if (role && role.value !== "tooltip") {
+        return role.value;
+      }
+      return void 0;
+    });
+    const ariaExpanded = vue.computed(() => {
+      return ariaHaspopup.value ? `${props.open}` : void 0;
+    });
+    let virtualTriggerAriaStopWatch = void 0;
+    const TRIGGER_ELE_EVENTS = [
+      "onMouseenter",
+      "onMouseleave",
+      "onClick",
+      "onKeydown",
+      "onFocus",
+      "onBlur",
+      "onContextmenu"
+    ];
+    vue.onMounted(() => {
+      vue.watch(
+        () => props.virtualRef,
+        (virtualEl) => {
+          if (virtualEl) {
+            triggerRef.value = index$1.unrefElement(virtualEl);
+          }
+        },
+        {
+          immediate: true
+        }
+      );
+      vue.watch(
+        triggerRef,
+        (el, prevEl) => {
+          virtualTriggerAriaStopWatch == null ? void 0 : virtualTriggerAriaStopWatch();
+          virtualTriggerAriaStopWatch = void 0;
+          if (types.isElement(prevEl)) {
+            TRIGGER_ELE_EVENTS.forEach((eventName) => {
+              const handler = props[eventName];
+              if (handler) {
+                prevEl.removeEventListener(
+                  eventName.slice(2).toLowerCase(),
+                  handler,
+                  ["onFocus", "onBlur"].includes(eventName)
+                );
+              }
+            });
+          }
+          if (types.isElement(el)) {
+            TRIGGER_ELE_EVENTS.forEach((eventName) => {
+              const handler = props[eventName];
+              if (handler) {
+                el.addEventListener(
+                  eventName.slice(2).toLowerCase(),
+                  handler,
+                  ["onFocus", "onBlur"].includes(eventName)
+                );
+              }
+            });
+            if (aria.isFocusable(el)) {
+              virtualTriggerAriaStopWatch = vue.watch(
+                [ariaControls, ariaDescribedby, ariaHaspopup, ariaExpanded],
+                (watches) => {
+                  [
+                    "aria-controls",
+                    "aria-describedby",
+                    "aria-haspopup",
+                    "aria-expanded"
+                  ].forEach((key, idx) => {
+                    isNil.default(watches[idx]) ? el.removeAttribute(key) : el.setAttribute(key, watches[idx]);
+                  });
+                },
+                { immediate: true }
+              );
+            }
+          }
+          if (types.isElement(prevEl) && aria.isFocusable(prevEl)) {
+            [
+              "aria-controls",
+              "aria-describedby",
+              "aria-haspopup",
+              "aria-expanded"
+            ].forEach((key) => prevEl.removeAttribute(key));
+          }
+        },
+        {
+          immediate: true
+        }
+      );
+    });
+    vue.onBeforeUnmount(() => {
+      virtualTriggerAriaStopWatch == null ? void 0 : virtualTriggerAriaStopWatch();
+      virtualTriggerAriaStopWatch = void 0;
+      if (triggerRef.value && types.isElement(triggerRef.value)) {
+        const el = triggerRef.value;
+        TRIGGER_ELE_EVENTS.forEach((eventName) => {
+          const handler = props[eventName];
+          if (handler) {
+            el.removeEventListener(
+              eventName.slice(2).toLowerCase(),
+              handler,
+              ["onFocus", "onBlur"].includes(eventName)
+            );
+          }
+        });
+        triggerRef.value = void 0;
+      }
+    });
+    __expose({
+      triggerRef
+    });
+    return (_ctx, _cache) => {
+      return !_ctx.virtualTriggering ? (vue.openBlock(), vue.createBlock(vue.unref(onlyChild.OnlyChild), vue.mergeProps({ key: 0 }, _ctx.$attrs, {
+        "aria-controls": ariaControls.value,
+        "aria-describedby": ariaDescribedby.value,
+        "aria-expanded": ariaExpanded.value,
+        "aria-haspopup": ariaHaspopup.value
+      }), {
+        default: vue.withCtx(() => [
+          vue.renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16, ["aria-controls", "aria-describedby", "aria-expanded", "aria-haspopup"])) : vue.createCommentVNode("v-if", true);
+    };
+  }
+});
+var ElPopperTrigger = /* @__PURE__ */ pluginVue_exportHelper.default(_sfc_main, [["__file", "/home/runner/work/element-plus/element-plus/packages/components/popper/src/trigger.vue"]]);
+exports.default = ElPopperTrigger;