@whitesev/pops 4.2.0 → 4.2.1

package/dist/index.amd.js

@@ -1,6 +1,6 @@
 define((function () { 'use strict';
 
-  const version = "4.2.0";
+  const version = "4.2.1";
 
   const GlobalConfig = {
       config: {},
@@ -816,7 +816,7 @@ define((function () { 'use strict';
            * @param startIndex
            * @param option
            */
-          function getOption(args, startIndex, option) {
+          const getOption = function (args, startIndex, option) {
               const currentParam = args[startIndex];
               if (typeof currentParam === "boolean") {
                   option.capture = currentParam;
@@ -838,7 +838,7 @@ define((function () { 'use strict';
                   option.isComposedPath = currentParam.isComposedPath;
               }
               return option;
-          }
+          };
           const that = this;
           // eslint-disable-next-line prefer-rest-params
           const args = arguments;
@@ -853,8 +853,7 @@ define((function () { 'use strict';
           }
           let $elList = [];
           if (element instanceof NodeList || Array.isArray(element)) {
-              element = element;
-              $elList = [...element];
+              $elList = $elList.concat(Array.from(element));
           }
           else {
               $elList.push(element);
@@ -862,15 +861,15 @@ define((function () { 'use strict';
           // 事件名
           let eventTypeList = [];
           if (Array.isArray(eventType)) {
-              eventTypeList = eventTypeList.concat(eventType.filter((eventTypeItem) => typeof eventTypeItem === "string" && eventTypeItem.toString() !== ""));
+              eventTypeList = eventTypeList.concat(eventType.filter((it) => typeof it === "string" && it.toString() !== ""));
           }
           else if (typeof eventType === "string") {
-              eventTypeList = eventTypeList.concat(eventType.split(" ").filter((eventTypeItem) => eventTypeItem !== ""));
+              eventTypeList = eventTypeList.concat(eventType.split(" ").filter((it) => it !== ""));
           }
           // 子元素选择器
           let selectorList = [];
           if (Array.isArray(selector)) {
-              selectorList = selectorList.concat(selector.filter((selectorItem) => typeof selectorItem === "string" && selectorItem.toString() !== ""));
+              selectorList = selectorList.concat(selector.filter((it) => typeof it === "string" && it.toString() !== ""));
           }
           else if (typeof selector === "string") {
               selectorList.push(selector);
@@ -897,39 +896,52 @@ define((function () { 'use strict';
           /**
            * 如果是once，那么删除该监听和元素上的事件和监听
            */
-          function checkOptionOnceToRemoveEventListener() {
+          const checkOptionOnceToRemoveEventListener = ($el) => {
               if (listenerOption.once) {
-                  that.off(element, eventType, selector, callback, option);
+                  this.off($el, eventTypeList, selector, callback, option);
               }
-          }
-          $elList.forEach((elementItem) => {
+          };
+          $elList.forEach(($elItem) => {
               /**
                * 事件回调
                * @param event
                */
-              function domUtilsEventCallBack(event) {
+              const handlerCallBack = function (event) {
+                  let call_this = void 0;
+                  let call_event = void 0;
+                  let call_$selector = void 0;
+                  let execCallback = false;
                   if (selectorList.length) {
                       // 存在子元素选择器
                       // 这时候的this和target都是子元素选择器的元素
-                      let eventTarget = listenerOption.isComposedPath
-                          ? event.composedPath()[0]
-                          : event.target;
-                      let totalParent = elementItem;
-                      if (popsUtils.isWin(totalParent)) {
-                          if (totalParent === PopsCore.document) {
-                              totalParent = PopsCore.document.documentElement;
+                      let $target;
+                      if (listenerOption.isComposedPath) {
+                          // 可能为空
+                          const composedPath = event.composedPath();
+                          if (!composedPath.length && event.target) {
+                              composedPath.push(event.target);
                           }
+                          $target = composedPath[0];
+                      }
+                      else {
+                          $target = event.target;
                       }
-                      const findValue = selectorList.find((selectorItem) => {
+                      let $parent = $elItem;
+                      if (popsUtils.isWin($parent)) {
+                          // window和document共用一个对象
+                          // 这样就能处理子元素选择器无法匹配的问题
+                          $parent = PopsCore.document.documentElement;
+                      }
+                      const findValue = selectorList.find((selectors) => {
                           // 判断目标元素是否匹配选择器
-                          if (that.matches(eventTarget, selectorItem)) {
+                          if (that.matches($target, selectors)) {
                               // 当前目标可以被selector所匹配到
                               return true;
                           }
                           // 在上层与主元素之间寻找可以被selector所匹配到的
-                          const $closestMatches = that.closest(eventTarget, selectorItem);
-                          if ($closestMatches && totalParent?.contains($closestMatches)) {
-                              eventTarget = $closestMatches;
+                          const $closestMatches = that.closest($target, selectors);
+                          if ($closestMatches && $parent?.contains?.($closestMatches)) {
+                              $target = $closestMatches;
                               return true;
                           }
                           return false;
@@ -939,38 +951,47 @@ define((function () { 'use strict';
                           try {
                               OriginPrototype.Object.defineProperty(event, "target", {
                                   get() {
-                                      return eventTarget;
+                                      return $target;
                                   },
                               });
+                              // oxlint-disable-next-line no-empty
                           }
-                          catch {
-                              // 忽略
-                          }
-                          listenerCallBack.call(eventTarget, event, eventTarget);
-                          checkOptionOnceToRemoveEventListener();
+                          catch { }
+                          execCallback = true;
+                          call_this = $target;
+                          call_event = event;
+                          call_$selector = $target;
                       }
                   }
                   else {
-                      // 这时候的this指向监听的元素
-                      listenerCallBack.call(elementItem, event);
-                      checkOptionOnceToRemoveEventListener();
+                      execCallback = true;
+                      call_this = $elItem;
+                      call_event = event;
+                  }
+                  if (execCallback) {
+                      const result = listenerCallBack.call(call_this, call_event, call_$selector);
+                      checkOptionOnceToRemoveEventListener($elItem);
+                      if (typeof result === "boolean" && !result) {
+                          return false;
+                      }
                   }
-              }
+              };
               // 遍历事件名设置元素事件
               eventTypeList.forEach((eventName) => {
-                  elementItem.addEventListener(eventName, domUtilsEventCallBack, listenerOption);
+                  // add listener
+                  $elItem.addEventListener(eventName, handlerCallBack, listenerOption);
                   // 获取对象上的事件
-                  const elementEvents = Reflect.get(elementItem, SymbolEvents) || {};
+                  const elementEvents = Reflect.get($elItem, SymbolEvents) || {};
                   // 初始化对象上的xx事件
                   elementEvents[eventName] = elementEvents[eventName] || [];
                   elementEvents[eventName].push({
                       selector: selectorList,
                       option: listenerOption,
-                      callback: domUtilsEventCallBack,
-                      originCallBack: listenerCallBack,
+                      handlerCallBack: handlerCallBack,
+                      callback: listenerCallBack,
                   });
                   // 覆盖事件
-                  Reflect.set(elementItem, SymbolEvents, elementEvents);
+                  Reflect.set($elItem, SymbolEvents, elementEvents);
               });
           });
           return {
@@ -983,11 +1004,11 @@ define((function () { 'use strict';
               },
               /**
                * 主动触发事件
-               * @param details 赋予触发的Event的额外属性，如果是Event类型，那么将自动代替默认new的Event对象
-               * @param useDispatchToEmit 是否使用dispatchEvent来触发事件，默认true，如果为false，则直接调用callback，但是这种会让使用了selectorTarget的没有值
+               * @param extraDetails 赋予触发的Event的额外属性，如果是Event类型，那么将自动代替默认new的Event对象
+               * @param useDispatchToTriggerEvent 是否使用dispatchEvent来触发事件，默认true，如果为false，则直接调用callback，但是这种会让使用了`$selector`的没有值
                */
-              emit: (details, useDispatchToEmit) => {
-                  that.emit($elList, eventTypeList, details, useDispatchToEmit);
+              emit: (extraDetails, useDispatchToTriggerEvent) => {
+                  that.emit($elList, eventTypeList, extraDetails, useDispatchToTriggerEvent);
               },
           };
       }
@@ -998,7 +1019,7 @@ define((function () { 'use strict';
            * @param startIndex
            * @param option
            */
-          function getOption(args1, startIndex, option) {
+          const getOption = function (args1, startIndex, option) {
               const currentParam = args1[startIndex];
               if (typeof currentParam === "boolean") {
                   option.capture = currentParam;
@@ -1007,12 +1028,12 @@ define((function () { 'use strict';
                   option.capture = currentParam.capture;
               }
               return option;
-          }
-          const DOMUtilsContext = this;
+          };
+          const that = this;
           // eslint-disable-next-line prefer-rest-params
           const args = arguments;
           if (typeof element === "string") {
-              element = DOMUtilsContext.selectorAll(element);
+              element = that.selectorAll(element);
           }
           if (element == null) {
               return;
@@ -1020,22 +1041,22 @@ define((function () { 'use strict';
           let $elList = [];
           if (element instanceof NodeList || Array.isArray(element)) {
               element = element;
-              $elList = $elList.concat(element);
+              $elList = $elList.concat(Array.from(element));
           }
           else {
               $elList.push(element);
           }
           let eventTypeList = [];
           if (Array.isArray(eventType)) {
-              eventTypeList = eventTypeList.concat(eventType.filter((eventTypeItem) => typeof eventTypeItem === "string" && eventTypeItem.toString() !== ""));
+              eventTypeList = eventTypeList.concat(eventType.filter((it) => typeof it === "string" && it.toString() !== ""));
           }
           else if (typeof eventType === "string") {
-              eventTypeList = eventTypeList.concat(eventType.split(" ").filter((eventTypeItem) => eventTypeItem !== ""));
+              eventTypeList = eventTypeList.concat(eventType.split(" ").filter((it) => it !== ""));
           }
           // 子元素选择器
           let selectorList = [];
           if (Array.isArray(selector)) {
-              selectorList = selectorList.concat(selector.filter((selectorItem) => typeof selectorItem === "string" && selectorItem.toString() !== ""));
+              selectorList = selectorList.concat(selector.filter((it) => typeof it === "string" && it.toString() !== ""));
           }
           else if (typeof selector === "string") {
               selectorList.push(selector);
@@ -1064,16 +1085,16 @@ define((function () { 'use strict';
               // 目标函数、事件名、回调函数、事件配置、过滤函数
               filter = option;
           }
-          $elList.forEach((elementItem) => {
+          $elList.forEach(($elItem) => {
               // 获取对象上的事件
-              const elementEvents = Reflect.get(elementItem, SymbolEvents) || {};
+              const elementEvents = Reflect.get($elItem, SymbolEvents) || {};
               eventTypeList.forEach((eventName) => {
                   const handlers = elementEvents[eventName] || [];
                   const filterHandler = typeof filter === "function" ? handlers.filter(filter) : handlers;
                   for (let index = 0; index < filterHandler.length; index++) {
                       const handler = filterHandler[index];
                       let flag = true;
-                      if (flag && listenerCallBack && handler.originCallBack !== listenerCallBack) {
+                      if (flag && listenerCallBack && handler.callback !== listenerCallBack) {
                           // callback不同
                           flag = false;
                       }
@@ -1090,7 +1111,7 @@ define((function () { 'use strict';
                           flag = false;
                       }
                       if (flag) {
-                          elementItem.removeEventListener(eventName, handler.callback, handler.option);
+                          $elItem.removeEventListener(eventName, handler.handlerCallBack, handler.option);
                           const findIndex = handlers.findIndex((item) => item === handler);
                           if (findIndex !== -1) {
                               handlers.splice(findIndex, 1);
@@ -1102,7 +1123,7 @@ define((function () { 'use strict';
                       popsUtils.delete(elementEvents, eventType);
                   }
               });
-              Reflect.set(elementItem, SymbolEvents, elementEvents);
+              Reflect.set($elItem, SymbolEvents, elementEvents);
           });
       }
       /**
@@ -1486,11 +1507,11 @@ define((function () { 'use strict';
            * 阻止事件的默认行为发生，并阻止事件传播
            */
           const stopEvent = (event, onlyStopPropagation) => {
+              // 停止事件的传播，阻止它继续向更上层的元素冒泡，事件将不会再传播给其他的元素
+              event?.stopPropagation();
+              // 阻止事件传播，并且还能阻止元素上的其他事件处理程序被触发
+              event?.stopImmediatePropagation();
               if (typeof onlyStopPropagation === "boolean" && onlyStopPropagation) {
-                  // 停止事件的传播，阻止它继续向更上层的元素冒泡，事件将不会再传播给其他的元素
-                  event?.stopPropagation();
-                  // 阻止事件传播，并且还能阻止元素上的其他事件处理程序被触发
-                  event?.stopImmediatePropagation();
                   return;
               }
               // 阻止事件的默认行为发生。例如，当点击一个链接时，浏览器会默认打开链接的URL，或者在输入框内输入文字