super-toolkit 1.0.4 → 1.0.5

package/src/data.ts

@@ -1,57 +1,182 @@
 /** 深拷贝 */
-export function deepClone<T>(val: T):T {
+export function deepClone<T>(val: T): T {
+  if (val === null || typeof val !== 'object') {
+    return val;
+  }
+  
+  // 处理 Date 类型
+  if (val instanceof Date) {
+    return new Date(val.getTime()) as T;
+  }
+  
+  // 处理 RegExp 类型
+  if (val instanceof RegExp) {
+    return new RegExp(val.source, val.flags) as T;
+  }
+  
+  // 处理 Array 类型
   if (Array.isArray(val)) {
-    let arr = [];
-    for (let i = 0; i < val.length; i++) {
-      arr[i] = deepClone(val[i])
+    var result: any[] = [];
+    for (var i = 0; i < val.length; i++) {
+      result.push(deepClone(val[i]));
     }
-    return arr as T
+    return result as T;
   }
-  if (typeof val === 'object' && val !== null) {
-    let obj: Record<string, unknown> = {};
-    for (let key in val) {
-      obj[key] = deepClone<unknown>(val[key])
+  
+  // 处理普通对象
+  if (typeof val === 'object') {
+    var obj: Record<string, any> = {};
+    for (var key in val) {
+      if (Object.prototype.hasOwnProperty.call(val, key)) {
+        obj[key] = deepClone(val[key]);
+      }
     }
-    return obj as T
+    return obj as T;
   }
-  return val
+  
+  return val;
 }
+
 /** 判断是否为空字符串、null、undefined、空对象、空数组 */
-export function isEmpty(value: string | number | null | undefined | Array<any> | Record<string, any>) {
+export function isEmpty(value: any): boolean {
   if (value === '' || value === null || value === undefined) {
     return true;
   } else if (typeof value === 'object') {
     if (Array.isArray(value)) {
       return value.length === 0;
     } else {
-      return Object.keys(value).length === 0;
+      // 兼容 IE8 的对象键获取
+      var hasKeys = false;
+      for (var key in value) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+          hasKeys = true;
+          break;
+        }
+      }
+      return !hasKeys;
     }
   }
   return false;
 }
+
 /** 数据分组筛选 */
-export function group <T extends Array<Record<string,any>> = any[]>(array:T, keys:string[]) {
-  const data:{
-    group:string
-    data:T
-  }[] = []
-  array.forEach(item => {
-    const groups = data.map(t => t.group)
-    const values = keys.map(t => item[t])
-    if(values.includes(undefined)) throw Error('传入的keys有误')
-    if (groups.includes(values.join(','))) {
-      data.forEach(ct => {
-        if (ct.group == item.age) {
-          ct.data.push(item)
-        }
-      })
+export function group<T extends Array<Record<string, any>>>(array: T, keys: string[]): { group: string; data: T }[] {
+  // 使用对象替代 Map
+  var dataMap: Record<string, T> = {};
+  
+  for (var i = 0; i < array.length; i++) {
+    var item = array[i];
+    var values = [];
+    for (var j = 0; j < keys.length; j++) {
+      values.push(item[keys[j]]);
+    }
+    
+    // 检查是否包含 undefined
+    var hasUndefined = false;
+    for (var k = 0; k < values.length; k++) {
+      if (values[k] === undefined) {
+        hasUndefined = true;
+        break;
+      }
     }
-    else {
-      data.push({
-        group: values.join(','),
-        data: [item] as T
-      })
+    if (hasUndefined) {
+      throw new Error('传入的keys有误');
+    }
+    
+    var groupKey = values.join(',');
+    if (dataMap[groupKey]) {
+      dataMap[groupKey].push(item);
+    } else {
+      dataMap[groupKey] = [item] as T;
     }
-  })
-  return data
+  }
+  
+  // 转换为数组
+  var result = [];
+  for (var key in dataMap) {
+    if (Object.prototype.hasOwnProperty.call(dataMap, key)) {
+      result.push({ group: key, data: dataMap[key] });
+    }
+  }
+  return result;
+}
+
+/** 返回参数的数据类型 */
+export function getDataType(data: any): string {
+  return Object.prototype.toString.call(data).slice(8, -1);
+}
+
+/** 判断两个参数的数据是否一样 */
+export function isSame(sourceData: any, compareData: any): boolean {
+  if (arguments.length < 2) {
+    throw new Error('Incorrect number of parameters');
+  }
+  
+  var sourceType = getDataType(sourceData);
+  if (sourceType !== getDataType(compareData)) {
+    return false;
+  }
+  
+  // 处理基本类型
+  if (sourceType !== 'Array' && sourceType !== 'Object') {
+    if (sourceType === 'Number' && isNaN(sourceData)) {
+      return isNaN(compareData);
+    }
+    if (sourceType === 'Date' || sourceType === 'RegExp') {
+      return sourceData.toString() === compareData.toString();
+    }
+    return sourceData === compareData;
+  }
+  
+  // 处理数组
+  if (sourceType === 'Array') {
+    if (sourceData.length !== compareData.length) {
+      return false;
+    }
+    for (var i = 0; i < sourceData.length; i++) {
+      if (!isSame(sourceData[i], compareData[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  
+  // 处理对象
+  if (sourceType === 'Object') {
+    // 兼容 IE8 的对象键获取
+    var sourceKeys = [];
+    for (var key in sourceData) {
+      if (Object.prototype.hasOwnProperty.call(sourceData, key)) {
+        sourceKeys.push(key);
+      }
+    }
+    
+    var compareKeys = [];
+    for (var key in compareData) {
+      if (Object.prototype.hasOwnProperty.call(compareData, key)) {
+        compareKeys.push(key);
+      }
+    }
+    
+    if (sourceKeys.length !== compareKeys.length) {
+      return false;
+    }
+    
+    for (var i = 0; i < sourceKeys.length; i++) {
+      var key = sourceKeys[i];
+      var hasKey = false;
+      for (var j = 0; j < compareKeys.length; j++) {
+        if (compareKeys[j] === key) {
+          hasKey = true;
+          break;
+        }
+      }
+      if (!hasKey || !isSame(sourceData[key], compareData[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  
+  return true;
 }

package/src/element.ts

@@ -1,7 +1,88 @@
+/** 字符串 trim 方法兼容 IE8 */
+function trim(str: string): string {
+  return str.replace(/^\s+|\s+$/g, '');
+}
+
 /** 获取指定元素中的所有内容 */
-export function getElementContent(msg: string, el: string) {
-  let elReg = new RegExp("<" + el + "[\\s\\S]*<\\/" + el + ">");
-  console.log(elReg);
-  let newEl = elReg.exec(msg);
-  return newEl?.length ? newEl[0] : null
+export function getElementContent(msg: string, el: string): string | null {
+  // 参数验证
+  if (typeof msg !== 'string' || typeof el !== 'string') {
+    return null;
+  }
+  
+  // 验证元素名称是否合法
+  if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(el)) {
+    return null;
+  }
+  
+  try {
+    // 构建正则表达式，使用非贪婪匹配，处理属性和自闭合标签
+    var elReg = new RegExp('<' + el + '[^>]*>([\\s\\S]*?)<\\/' + el + '>', 'i');
+    var match = elReg.exec(msg);
+    
+    // 返回匹配到的内容，如果没有匹配到则返回 null
+    return match ? match[0] : null;
+  } catch (error) {
+    // 处理可能的错误
+    return null;
+  }
+}
+
+/** 获取指定元素中的文本内容 */
+export function getElementText(msg: string, el: string): string | null {
+  // 参数验证
+  if (typeof msg !== 'string' || typeof el !== 'string') {
+    return null;
+  }
+  
+  // 验证元素名称是否合法
+  if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(el)) {
+    return null;
+  }
+  
+  try {
+    // 构建正则表达式，使用非贪婪匹配
+    var elReg = new RegExp('<' + el + '[^>]*>([\\s\\S]*?)<\\/' + el + '>', 'i');
+    var match = elReg.exec(msg);
+    
+    if (match) {
+      // 移除可能的标签，只保留文本内容
+      return trim(match[1].replace(/<[^>]+>/g, ''));
+    }
+    
+    return null;
+  } catch (error) {
+    // 处理可能的错误
+    return null;
+  }
+}
+
+/** 获取所有指定元素 */
+export function getAllElements(msg: string, el: string): string[] {
+  // 参数验证
+  if (typeof msg !== 'string' || typeof el !== 'string') {
+    return [];
+  }
+  
+  // 验证元素名称是否合法
+  if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(el)) {
+    return [];
+  }
+  
+  try {
+    // 构建正则表达式，使用非贪婪匹配
+    var elReg = new RegExp('<' + el + '[^>]*>([\\s\\S]*?)<\\/' + el + '>', 'gi');
+    var matches: string[] = [];
+    var match;
+    
+    // 收集所有匹配结果
+    while ((match = elReg.exec(msg)) !== null) {
+      matches.push(match[0]);
+    }
+    
+    return matches;
+  } catch (error) {
+    // 处理可能的错误
+    return [];
+  }
 }

package/src/event.ts

@@ -1,32 +1,106 @@
-/**防抖方法，其中形参fn为要执行的方法，wait则代表时间间隔,v2使用方法：methods:debounce(()=>{},500),v3使用方法:const methods=debounce(()=>{},500)*/
-export function onDebounce(fn: Function, wait: number) {
-  var timer: any = null;
-  return function (this: Window) {
-    var _that = this;
-    clearTimeout(timer as undefined)
-    timer = timer as typeof setTimeout;
-    timer = setTimeout(function () {
-      fn.apply(_that, arguments) //更改this指向，使this指向它的调用层
-    }, wait)
-  }
-}
-
-/**节流方法，其中形参fn为要执行的方法，wait则代表时间间隔,v2使用方法：methods:throttle(()=>{},500),v3使用方法:const methods=throttle(()=>{},500)*/
-export function onThrottle(fn: Function, wait: number) {
-  var timeout: any, startTime = new Date() as any;
-  return function (this: Window) {
-    var _that = this;
-    var curTime = new Date() as any;
-    clearTimeout(timeout);
-    // 如果达到了规定的触发时间间隔，触发 handler
-    if (curTime - startTime >= wait) {
-      fn.apply(_that, arguments);//更改this指向，使this指向它的调用层
-      startTime = curTime;
-      // 没达到触发间隔，重新设定定时器
+/** 
+ * 防抖方法
+ * @param fn 要执行的函数
+ * @param wait 时间间隔（毫秒）
+ * @param immediate 是否立即执行
+ * @returns 防抖处理后的函数
+ * @example
+ * // v2使用方法：methods:debounce(()=>{},500)
+ * // v3使用方法:const methods=debounce(()=>{},500)
+ */
+export function debounce(fn: Function, wait: number, immediate: boolean = false) {
+  let timer: any = null;
+  
+  const debounced = function(this: any) {
+    const context = this;
+    const args = arguments;
+    
+    if (timer) {
+      clearTimeout(timer);
+    }
+    
+    if (immediate) {
+      const callNow = !timer;
+      timer = setTimeout(() => {
+        timer = null;
+      }, wait);
+      
+      if (callNow) {
+        fn.apply(context, args);
+      }
     } else {
-      timeout = setTimeout(function () {
-        fn.apply(_that, arguments);//更改this指向，使this指向它的调用层
+      timer = setTimeout(() => {
+        fn.apply(context, args);
       }, wait);
     }
   };
+  
+  // 添加取消方法
+  debounced.cancel = function() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+  
+  return debounced;
+}
+
+/** 
+ * 节流方法
+ * @param fn 要执行的函数
+ * @param wait 时间间隔（毫秒）
+ * @param options 配置选项
+ * @returns 节流处理后的函数
+ * @example
+ * // v2使用方法：methods:throttle(()=>{},500)
+ * // v3使用方法:const methods=throttle(()=>{},500)
+ */
+export function throttle(fn: Function, wait: number, options: any = {}) {
+  let timeout: any = null;
+  let lastTime = 0;
+  const leading = options.leading !== false;
+  const trailing = options.trailing !== false;
+  
+  const throttled = function(this: any) {
+    const context = this;
+    const args = arguments;
+    const now = Date.now();
+    
+    // 首次执行时，如果不允许立即执行，则设置 lastTime 为当前时间
+    if (!lastTime && !leading) {
+      lastTime = now;
+    }
+    
+    // 计算剩余时间
+    const remaining = wait - (now - lastTime);
+    
+    if (remaining <= 0 || remaining > wait) {
+      // 达到时间间隔，执行函数
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+      lastTime = now;
+      fn.apply(context, args);
+    } else if (!timeout && trailing) {
+      // 未达到时间间隔，设置定时器
+      timeout = setTimeout(() => {
+        lastTime = leading ? Date.now() : 0;
+        timeout = null;
+        fn.apply(context, args);
+      }, remaining);
+    }
+  };
+  
+  // 添加取消方法
+  throttled.cancel = function() {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = null;
+    }
+    lastTime = 0;
+  };
+  
+  return throttled;
 }