@element-plus/nightly 0.0.20250803 → 0.0.20250805

package/dist/index.full.js

@@ -1,4 +1,4 @@
-/*! Element Plus v0.0.20250803 */
+/*! Element Plus v0.0.20250805 */
 
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue')) :
@@ -757,6 +757,65 @@
     };
   }
 
+  function useIntersectionObserver(target, callback, options = {}) {
+    const {
+      root,
+      rootMargin = "0px",
+      threshold = 0.1,
+      window = defaultWindow,
+      immediate = true
+    } = options;
+    const isSupported = useSupported(() => window && "IntersectionObserver" in window);
+    const targets = vue.computed(() => {
+      const _target = toValue(target);
+      return (Array.isArray(_target) ? _target : [_target]).map(unrefElement).filter(notNullish);
+    });
+    let cleanup = noop$1;
+    const isActive = vue.ref(immediate);
+    const stopWatch = isSupported.value ? vue.watch(
+      () => [targets.value, unrefElement(root), isActive.value],
+      ([targets2, root2]) => {
+        cleanup();
+        if (!isActive.value)
+          return;
+        if (!targets2.length)
+          return;
+        const observer = new IntersectionObserver(
+          callback,
+          {
+            root: unrefElement(root2),
+            rootMargin,
+            threshold
+          }
+        );
+        targets2.forEach((el) => el && observer.observe(el));
+        cleanup = () => {
+          observer.disconnect();
+          cleanup = noop$1;
+        };
+      },
+      { immediate, flush: "post" }
+    ) : noop$1;
+    const stop = () => {
+      cleanup();
+      stopWatch();
+      isActive.value = false;
+    };
+    tryOnScopeDispose(stop);
+    return {
+      isSupported,
+      isActive,
+      pause() {
+        cleanup();
+        isActive.value = false;
+      },
+      resume() {
+        isActive.value = true;
+      },
+      stop
+    };
+  }
+
   function useVModel(props, key, emit, options = {}) {
     var _a, _b, _c;
     const {
@@ -868,23 +927,6 @@
 
   const isFirefox = () => isClient && /firefox/i.test(window.navigator.userAgent);
 
-  const isInContainer = (el, container) => {
-    if (!isClient || !el || !container)
-      return false;
-    const elRect = el.getBoundingClientRect();
-    let containerRect;
-    if (container instanceof Element) {
-      containerRect = container.getBoundingClientRect();
-    } else {
-      containerRect = {
-        top: 0,
-        right: window.innerWidth,
-        bottom: window.innerHeight,
-        left: 0
-      };
-    }
-    return elRect.top < containerRect.bottom && elRect.bottom > containerRect.top && elRect.right > containerRect.left && elRect.left < containerRect.right;
-  };
   const getOffsetTop = (el) => {
     let offset = 0;
     let parent = el;
@@ -11832,7 +11874,7 @@
 
   const ElConfigProvider = withInstall(ConfigProvider);
 
-  const version$1 = "0.0.20250803";
+  const version$1 = "0.0.20250805";
 
   const makeInstaller = (components = []) => {
     const install = (app, options) => {
@@ -29031,10 +29073,15 @@
       }
     }, { immediate: true });
     vue.watch(() => props.parsedValue, (parsedValue) => {
-      if (!props.visible || !(parsedValue == null ? void 0 : parsedValue.length)) {
+      if (!(parsedValue == null ? void 0 : parsedValue.length)) {
         onReset(parsedValue);
       }
     }, { immediate: true });
+    vue.watch(() => props.visible, () => {
+      if (props.visible) {
+        onReset(props.parsedValue);
+      }
+    }, { immediate: true });
     return {
       minDate,
       maxDate,
@@ -29160,6 +29207,7 @@
       const { lang } = useLocale();
       const leftDate = vue.ref(dayjs().locale(lang.value));
       const rightDate = vue.ref(dayjs().locale(lang.value).add(1, unit$2));
+      let shouldBeVisible = true;
       const {
         minDate,
         maxDate,
@@ -29332,12 +29380,16 @@
         emit("calendar-change", [min_.toDate(), max_ && max_.toDate()]);
         maxDate.value = maxDate_;
         minDate.value = minDate_;
-        handleRangeConfirm(close);
+        if (!showTime.value && close) {
+          close = !minDate_ || !maxDate_;
+        }
+        shouldBeVisible = close;
       };
-      vue.watch([maxDate, minDate], ([min, max]) => {
-        if (min && max)
-          handleRangeConfirm(true);
-      }, { flush: "post" });
+      vue.watch([maxDate, minDate], ([max, min]) => {
+        if (max && min) {
+          handleRangeConfirm(shouldBeVisible);
+        }
+      });
       const minTimePickerVisible = vue.ref(false);
       const maxTimePickerVisible = vue.ref(false);
       const handleMinTimeClose = () => {
@@ -33719,8 +33771,8 @@
         hasLoadError.value = true;
         emit("error", event);
       }
-      function handleLazyLoad() {
-        if (isInContainer(container.value, _scrollContainer.value)) {
+      function handleLazyLoad(isIntersecting) {
+        if (isIntersecting) {
           loadImage();
           removeLazyLoadListener();
         }
@@ -33737,18 +33789,20 @@
         } else if (isString$1(scrollContainer) && scrollContainer !== "") {
           _scrollContainer.value = (_a = document.querySelector(scrollContainer)) != null ? _a : void 0;
         } else if (container.value) {
-          _scrollContainer.value = getScrollContainer(container.value);
-        }
-        if (_scrollContainer.value) {
-          stopScrollListener = useEventListener(_scrollContainer, "scroll", lazyLoadHandler);
-          setTimeout(() => handleLazyLoad(), 100);
+          const scrollContainer2 = getScrollContainer(container.value);
+          _scrollContainer.value = isWindow$1(scrollContainer2) ? void 0 : scrollContainer2;
         }
+        const { stop } = useIntersectionObserver(container, ([entry]) => {
+          lazyLoadHandler(entry.isIntersecting);
+        }, { root: _scrollContainer });
+        stopScrollListener = stop;
       }
       function removeLazyLoadListener() {
-        if (!isClient || !_scrollContainer.value || !lazyLoadHandler)
+        if (!isClient || !lazyLoadHandler)
           return;
         stopScrollListener == null ? void 0 : stopScrollListener();
         _scrollContainer.value = void 0;
+        stopScrollListener = void 0;
       }
       function clickHandler() {
         if (!preview.value)
@@ -42890,10 +42944,12 @@
               name: "header",
               fn: vue.withCtx(() => [
                 vue.createElementVNode("div", {
-                  class: vue.normalizeClass(_ctx.nsSelect.be("dropdown", "header"))
+                  class: vue.normalizeClass(_ctx.nsSelect.be("dropdown", "header")),
+                  onClick: vue.withModifiers(() => {
+                  }, ["stop"])
                 }, [
                   vue.renderSlot(_ctx.$slots, "header")
-                ], 2)
+                ], 10, ["onClick"])
               ])
             } : void 0,
             _ctx.$slots.loading && _ctx.loading ? {
@@ -42921,10 +42977,12 @@
               name: "footer",
               fn: vue.withCtx(() => [
                 vue.createElementVNode("div", {
-                  class: vue.normalizeClass(_ctx.nsSelect.be("dropdown", "footer"))
+                  class: vue.normalizeClass(_ctx.nsSelect.be("dropdown", "footer")),
+                  onClick: vue.withModifiers(() => {
+                  }, ["stop"])
                 }, [
                   vue.renderSlot(_ctx.$slots, "footer")
-                ], 2)
+                ], 10, ["onClick"])
               ])
             } : void 0
           ]), 1032, ["data", "width", "hovering-index", "scrollbar-always-on"])
@@ -60489,7 +60547,8 @@
     setup(__props, { emit: emits }) {
       const props = __props;
       const ns = useNamespace("splitter");
-      const { containerEl, containerSize } = useContainer(vue.toRef(props, "layout"));
+      const layout = vue.toRef(props, "layout");
+      const { containerEl, containerSize } = useContainer(layout);
       const {
         removeChild: unregisterPanel,
         children: panels,
@@ -60523,7 +60582,7 @@
         panels,
         percentSizes,
         pxSizes,
-        layout: props.layout,
+        layout,
         movingIndex,
         containerSize,
         onMoveStart: onResizeStart,
@@ -60537,14 +60596,14 @@
         return vue.openBlock(), vue.createElementBlock("div", {
           ref_key: "containerEl",
           ref: containerEl,
-          class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(ns).e(_ctx.layout)])
+          class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(ns).e(vue.unref(layout))])
         }, [
           vue.renderSlot(_ctx.$slots, "default"),
           vue.createVNode(vue.unref(PanelsSorter)),
           vue.createCommentVNode(" Prevent iframe touch events from breaking "),
           vue.unref(movingIndex) ? (vue.openBlock(), vue.createElementBlock("div", {
             key: 0,
-            class: vue.normalizeClass([vue.unref(ns).e("mask"), vue.unref(ns).e(`mask-${_ctx.layout}`)])
+            class: vue.normalizeClass([vue.unref(ns).e("mask"), vue.unref(ns).e(`mask-${vue.unref(layout)}`)])
           }, null, 2)) : vue.createCommentVNode("v-if", true)
         ], 2);
       };