tools-min-ns 1.5.2

package/esm/env/EnvUtil.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 环境判断工具
+ * @description
+ * @author nanshen
+ * @creat 2023-12-15 10:30:30
+ */
+declare namespace EnvUtil {
+    /** @name Web */
+    const isWeb: boolean;
+    /** @name Node.js */
+    const isNode: boolean;
+    /** @name Weex */
+    const isWeex: boolean;
+    /** @name 阿里小程序环境 */
+    const isMiniApp: boolean;
+    /** @name 字节跳动小程序环境 */
+    const isByteDanceMicroApp: boolean;
+    /** @name 百度小程序环境 */
+    const isBaiduSmartProgram: boolean;
+    /** @name 快手小程序环境 */
+    const isKuaiShouMiniProgram: boolean;
+    /** @name 微信小程序环境 */
+    const isWeChatMiniProgram: boolean;
+    /** @name 快应用 */
+    const isQuickApp: boolean;
+}
+export default EnvUtil;

package/esm/env/EnvUtil.js

@@ -0,0 +1,29 @@
+import env from './env';
+/**
+ * 环境判断工具
+ * @description
+ * @author nanshen
+ * @creat 2023-12-15 10:30:30
+ */
+var EnvUtil;
+(function (EnvUtil) {
+  /** @name Web */
+  EnvUtil.isWeb = env.isWeb;
+  /** @name Node.js */
+  EnvUtil.isNode = env.isNode;
+  /** @name Weex */
+  EnvUtil.isWeex = env.isWeex;
+  /** @name 阿里小程序环境 */
+  EnvUtil.isMiniApp = env.isMiniApp;
+  /** @name 字节跳动小程序环境 */
+  EnvUtil.isByteDanceMicroApp = env.isByteDanceMicroApp;
+  /** @name 百度小程序环境 */
+  EnvUtil.isBaiduSmartProgram = env.isBaiduSmartProgram;
+  /** @name 快手小程序环境 */
+  EnvUtil.isKuaiShouMiniProgram = env.isKuaiShouMiniProgram;
+  /** @name 微信小程序环境 */
+  EnvUtil.isWeChatMiniProgram = env.isWeChatMiniProgram;
+  /** @name 快应用 */
+  EnvUtil.isQuickApp = env.isQuickApp;
+})(EnvUtil || (EnvUtil = {}));
+export default EnvUtil;

package/esm/env/env.d.ts

@@ -0,0 +1,41 @@
+export const isWeb: boolean;
+export const isNode: boolean;
+export const isWeex: boolean;
+export const isKraken: boolean;
+export const isMiniApp: boolean;
+export const isByteDanceMicroApp: boolean;
+export const isBaiduSmartProgram: boolean;
+export const isKuaiShouMiniProgram: boolean;
+export const isWeChatMiniProgram: boolean;
+export const isQuickApp: boolean;
+export const isPHA: boolean;
+export const isFRM: any;
+export const isWindVane: boolean;
+declare namespace _default {
+    export { isWeb };
+    export { isNode };
+    export { isWeex };
+    export { isKraken };
+    export { isMiniApp };
+    export { isByteDanceMicroApp };
+    export { isBaiduSmartProgram };
+    export { isKuaiShouMiniProgram };
+    export { isWeChatMiniProgram };
+    export { isQuickApp };
+    export { isPHA };
+    export { isWindVane };
+    export { isFRM };
+    export { getGlobal };
+    export { getData };
+    export { setData };
+    export { getInstance };
+    export { setStorageSync };
+    export { getStorageSync };
+}
+export default _default;
+declare function getGlobal(): any;
+declare function getData(key: any): any;
+declare function setData(key: any, val: any): void;
+declare function getInstance(): any;
+declare function setStorageSync(key: any, val: any): void;
+declare function getStorageSync(key: any): any;

package/esm/env/env.js

@@ -0,0 +1,106 @@
+export var isWeb = typeof window !== 'undefined' && 'onload' in window;
+export var isNode = typeof process !== 'undefined' && !!(process.versions && process.versions.node);
+export var isWeex = typeof WXEnvironment !== 'undefined' && WXEnvironment.platform !== 'Web';
+export var isKraken = typeof __kraken__ !== 'undefined';
+export var isMiniApp = typeof my !== 'undefined' && my !== null && typeof my.alert !== 'undefined';
+export var isByteDanceMicroApp = typeof tt !== 'undefined' && tt !== null && typeof tt.showToast !== 'undefined';
+export var isBaiduSmartProgram = typeof swan !== 'undefined' && swan !== null && typeof swan.showToast !== 'undefined';
+export var isKuaiShouMiniProgram = typeof ks !== 'undefined' && ks !== null && typeof ks.showToast !== 'undefined';
+// In wechat mini program, wx.login is a function
+// In wechat mini propgram webview, there is no wx.login, but exist wx.miniProgram
+// In bytedance maicro app, there is wx variable.
+// In kuaishou mini program, there is wx variable.
+export var isWeChatMiniProgram = !isByteDanceMicroApp && typeof wx !== 'undefined' && wx !== null && (typeof wx.request !== 'undefined' || typeof wx.miniProgram !== 'undefined');
+export var isQuickApp = typeof global !== 'undefined' && global !== null && typeof global.callNative !== 'undefined' && !isWeex;
+export var isPHA = isWeb && typeof pha === 'object';
+export var isFRM = isMiniApp && isWeb && my.isFRM;
+// WindVane.call is a function while page importing windvane.js
+var ua = typeof navigator === 'object' ? navigator.userAgent || navigator.swuserAgent : '';
+export var isWindVane = /.+AliApp\((\w+)\/((?:\d+\.)+\d+)\).* .*(WindVane)(?:\/((?:\d+\.)+\d+))?.*/.test(ua) && isWeb && typeof WindVane !== 'undefined' && typeof WindVane.call !== 'undefined';
+function getGlobal() {
+  var global;
+  if (isWeb) {
+    global = window;
+  } else if (isMiniApp) {
+    global = my;
+  } else if (isWeChatMiniProgram) {
+    global = wx;
+  } else {
+    global = window;
+  }
+  return global;
+} // 设置全局变量
+function setData(key, val) {
+  if (isWeb) {
+    window[key] = val;
+  } else {
+    var app = getApp();
+    app[key] = val;
+  }
+} // 获取全局变量
+function getData(key) {
+  if (isWeb) {
+    return window[key];
+  } else {
+    var app = getApp();
+    return app[key];
+  }
+} // 获取全局实例
+function getInstance() {
+  return isWeb ? window : getApp();
+} // 设置storage
+function setStorageSync(key, val) {
+  var global = getGlobal();
+  var value = JSON.stringify({
+    val: val
+  });
+  if (isWeb) {
+    global.localStorage.setItem(key, value);
+  } else if (isMiniApp) {
+    global.setStorageSync({
+      key: key,
+      data: value
+    });
+  } else if (isWeChatMiniProgram) {
+    global.setStorageSync(key, value);
+  }
+} // 获取storage值
+function getStorageSync(key) {
+  var global = getGlobal();
+  var value;
+  if (isWeb) {
+    value = global.localStorage.getItem(key);
+  } else if (isMiniApp) {
+    value = global.getStorageSync({
+      key: key
+    });
+  } else if (isWeChatMiniProgram) {
+    value = global.getStorageSync(key);
+  }
+  try {
+    return JSON.parse(value).val || value;
+  } catch (err) {
+    return value;
+  }
+}
+export default {
+  isWeb: isWeb,
+  isNode: isNode,
+  isWeex: isWeex,
+  isKraken: isKraken,
+  isMiniApp: isMiniApp,
+  isByteDanceMicroApp: isByteDanceMicroApp,
+  isBaiduSmartProgram: isBaiduSmartProgram,
+  isKuaiShouMiniProgram: isKuaiShouMiniProgram,
+  isWeChatMiniProgram: isWeChatMiniProgram,
+  isQuickApp: isQuickApp,
+  isPHA: isPHA,
+  isWindVane: isWindVane,
+  isFRM: isFRM,
+  getGlobal: getGlobal,
+  getData: getData,
+  setData: setData,
+  getInstance: getInstance,
+  setStorageSync: setStorageSync,
+  getStorageSync: getStorageSync
+};

package/esm/func/FunctionUtil.d.ts

@@ -0,0 +1,77 @@
+declare namespace FunctionUtil {
+    /**
+   * 函数柯里化
+   * @param { Function } fn 方法
+   * @param { Any } agrs 参数，可选
+   * @example
+   * // 实现一个判断数据类型的方法
+      const checktype = function(type, content) {
+          return Object.prototype.toString.call(content) === `[object ${type}]`;
+      }
+      checktype('Number',2); => true
+      // 这种方法总是要把type参数传过去，如果写错了就会影响到正确的结果了，可以考虑下如何做到把“Number“做到复用
+      
+      const checktype = function(type, content) {
+          return Object.prototype.toString.call(content) === `[object ${type}]`;
+      }
+      const curry = curryFn(checktype)
+      const isNumber = curry('Number')
+      isNumber(2) => true
+      */
+    function curryFn(fn: any, ...arg: any): () => any;
+    /**
+     * 函数防抖
+     * @param fn 需要防抖的函数
+     * @param t 防抖时间，多久以后才能再执行 单位ms
+     * @param immediate true: 立刻执行方法且最后一次时间不执行, false: 等t时间之后再执行方法，如果t时间内执行，则在最后一次的t时间之后执行方法，类似动态搜索效果
+     * @example
+     * const query = debounceFn(()=>console.log(3),2000,true)
+     * query() => 3
+     * query()
+     * query()
+     * const query = debounceFn(()=>console.log(3),2000,false)
+     * query()
+     * query()
+     * query() => 3
+     */
+    function debounceFn<T extends Function>(fn: T, t?: number, immediate?: boolean): T;
+    /**
+     * 函数节流
+     * @param fn 需要节流的函数
+     * @param t 节流时间，多久以后执行一次方法 单位ms
+     * @example
+     * const query = throttleFn(()=>console.log(3),2000)
+     * query() => 3
+     * query()
+     * query()
+     */
+    function throttleFn<T extends Function>(fn: T, t?: number): T;
+    /**
+     * 函数只能调用一次
+     * @param { Function } fn  需要被处理的函数
+     * @example
+     *  const canOnlyFireOnce = once(()=>console.log(1));
+     *  for(let i =1;i<10;i++){
+     *    canOnlyFireOnce();
+     *  }
+     *  // 1
+     */
+    function once<T extends Function>(fn: T): T;
+    /**
+     * 睡眠函数, 阻塞代码 timer毫秒
+     * @param timer  睡眠时长 （毫秒） 执行后续的操作
+     * @return promise
+     * @example
+     * const fn = async () =>{
+     *  console.log(1)
+     *  await sleepFn(2000)
+     *  console.log(2)
+     * }
+     * fn()
+     *  1
+     *  //两秒后
+     *  2
+     */
+    function sleepFn(timer?: number): Promise<void>;
+}
+export default FunctionUtil;

package/esm/func/FunctionUtil.js

@@ -0,0 +1,215 @@
+var __read = this && this.__read || function (o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o),
+    r,
+    ar = [],
+    e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = {
+      error: error
+    };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray = this && this.__spreadArray || function (to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+};
+/**
+ * 函数工具
+ * @description
+ * @author nanshen
+ * @creat 2021-09-15 14:22:55
+ */
+import BaseUtil from "../base/BaseUtil";
+var FunctionUtil;
+(function (FunctionUtil) {
+  /**
+  * 函数柯里化
+  * @param { Function } fn 方法
+  * @param { Any } agrs 参数，可选
+  * @example
+  * // 实现一个判断数据类型的方法
+    const checktype = function(type, content) {
+        return Object.prototype.toString.call(content) === `[object ${type}]`;
+    }
+    checktype('Number',2); => true
+    // 这种方法总是要把type参数传过去，如果写错了就会影响到正确的结果了，可以考虑下如何做到把“Number“做到复用
+    
+    const checktype = function(type, content) {
+        return Object.prototype.toString.call(content) === `[object ${type}]`;
+    }
+    const curry = curryFn(checktype)
+    const isNumber = curry('Number')
+    isNumber(2) => true
+    */
+  function curryFn(fn) {
+    var arg = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+      arg[_i - 1] = arguments[_i];
+    }
+    if (!BaseUtil.isFunction(fn)) throw new Error("第一个参数必须是方法");
+    var _this = this;
+    var args = Array.from(arguments).slice(1);
+    // fn.length 属性指明函数的形参个数。
+    var len = fn.length;
+    return function () {
+      var _args = Array.from(arguments);
+      args.push.apply(args, __spreadArray([], __read(_args), false));
+      if (args.length < len) {
+        return curryFn.call.apply(curryFn, __spreadArray([_this, fn], __read(args), false));
+      }
+      return fn.apply(_this, args);
+    };
+  }
+  FunctionUtil.curryFn = curryFn;
+  /**
+   * 函数防抖
+   * @param fn 需要防抖的函数
+   * @param t 防抖时间，多久以后才能再执行 单位ms
+   * @param immediate true: 立刻执行方法且最后一次时间不执行, false: 等t时间之后再执行方法，如果t时间内执行，则在最后一次的t时间之后执行方法，类似动态搜索效果
+   * @example
+   * const query = debounceFn(()=>console.log(3),2000,true)
+   * query() => 3
+   * query()
+   * query()
+   * const query = debounceFn(()=>console.log(3),2000,false)
+   * query()
+   * query()
+   * query() => 3
+   */
+  function debounceFn(fn, t, immediate) {
+    if (t === void 0) {
+      t = 2000;
+    }
+    if (immediate === void 0) {
+      immediate = true;
+    }
+    if (!BaseUtil.isFunction(fn)) throw new Error("第一个参数必须是方法");
+    var time;
+    //  立刻执行第一次该方法
+    if (immediate) {
+      return function () {
+        clearTimeout(time);
+        if (!time) {
+          fn.apply(this, arguments);
+        }
+        time = setTimeout(function () {
+          setTimeout(time);
+          time = null;
+        }, t);
+      };
+    } else {
+      // 满足 time 时间结束之后自动执行一次该方法
+      return function () {
+        clearTimeout(time);
+        var that = this;
+        var arg = arguments;
+        time = setTimeout(function () {
+          setTimeout(time);
+          fn.apply(that, arg);
+          time = null;
+        }, t);
+      };
+    }
+  }
+  FunctionUtil.debounceFn = debounceFn;
+  /**
+   * 函数节流
+   * @param fn 需要节流的函数
+   * @param t 节流时间，多久以后执行一次方法 单位ms
+   * @example
+   * const query = throttleFn(()=>console.log(3),2000)
+   * query() => 3
+   * query()
+   * query()
+   */
+  function throttleFn(fn, t) {
+    if (t === void 0) {
+      t = 2000;
+    }
+    if (!BaseUtil.isFunction(fn)) throw new Error("第一个参数必须是方法");
+    var _fn = fn;
+    var time = null;
+    var first = true;
+    return function () {
+      var arg = arguments;
+      var _this = this;
+      if (first) {
+        _fn.apply(_this, arg);
+        first = false;
+        return;
+      }
+      if (time) return;
+      time = setTimeout(function () {
+        setTimeout(time);
+        time = null;
+        _fn.apply(_this, arg);
+      }, t);
+    };
+  }
+  FunctionUtil.throttleFn = throttleFn;
+  /**
+   * 函数只能调用一次
+   * @param { Function } fn  需要被处理的函数
+   * @example
+   *  const canOnlyFireOnce = once(()=>console.log(1));
+   *  for(let i =1;i<10;i++){
+   *    canOnlyFireOnce();
+   *  }
+   *  // 1
+   */
+  function once(fn) {
+    if (!BaseUtil.isFunction(fn)) throw new Error("参数必须是方法");
+    var result;
+    return function () {
+      if (fn) {
+        result = fn.apply(this, arguments);
+        fn = null;
+      }
+      return result;
+    };
+  }
+  FunctionUtil.once = once;
+  /**
+   * 睡眠函数, 阻塞代码 timer毫秒
+   * @param timer  睡眠时长 （毫秒） 执行后续的操作
+   * @return promise
+   * @example
+   * const fn = async () =>{
+   *  console.log(1)
+   *  await sleepFn(2000)
+   *  console.log(2)
+   * }
+   * fn()
+   *  1
+   *  //两秒后
+   *  2
+   */
+  function sleepFn(timer) {
+    if (timer === void 0) {
+      timer = 2000;
+    }
+    return new Promise(function (resolve) {
+      setTimeout(function () {
+        resolve();
+      }, timer);
+    });
+  }
+  FunctionUtil.sleepFn = sleepFn;
+})(FunctionUtil || (FunctionUtil = {}));
+export default FunctionUtil;

package/esm/index.d.ts

@@ -0,0 +1,19 @@
+export { default as ArrayUtil } from './array/ArrayUtil';
+export { default as TreeUtil } from './array/TreeUtil';
+export { default as BaseUtil } from './base/BaseUtil';
+export { default as BrowserUtil } from './browser/BrowserUtil';
+export { default as CheckUtil } from './check/CheckUtil';
+export { default as CookieUtil } from './cookie/CookieUtil';
+export { default as DateUtil } from './date/DateUtil';
+export { default as EnvUtil } from './env/EnvUtil';
+export { default as FunctionUtil } from './func/FunctionUtil';
+export { default as NumberUtil } from './number/NumberUtil';
+export { default as ObjectUtil } from './object/ObjectUtil';
+export { default as PasswordUtil } from './pwd/PasswordUtil';
+export { default as RequestUtil } from './request/RequestUtil';
+export { default as StorageUtil } from './storage/StorageUtil';
+export { default as StringUtil } from './string/StringUtil';
+export { default as SystemUtil } from './system/SystemUtil';
+export { default as MapTransferUtil } from './transfer/MapTransferUtil';
+export { default as TransferUtil } from './transfer/TransferUtil';
+export { default as UrlUtil } from './url/UrlUtil';

package/esm/index.js

@@ -0,0 +1,19 @@
+export { default as ArrayUtil } from './array/ArrayUtil';
+export { default as TreeUtil } from './array/TreeUtil';
+export { default as BaseUtil } from './base/BaseUtil';
+export { default as BrowserUtil } from './browser/BrowserUtil';
+export { default as CheckUtil } from './check/CheckUtil';
+export { default as CookieUtil } from './cookie/CookieUtil';
+export { default as DateUtil } from './date/DateUtil';
+export { default as EnvUtil } from './env/EnvUtil';
+export { default as FunctionUtil } from './func/FunctionUtil';
+export { default as NumberUtil } from './number/NumberUtil';
+export { default as ObjectUtil } from './object/ObjectUtil';
+export { default as PasswordUtil } from './pwd/PasswordUtil';
+export { default as RequestUtil } from './request/RequestUtil';
+export { default as StorageUtil } from './storage/StorageUtil';
+export { default as StringUtil } from './string/StringUtil';
+export { default as SystemUtil } from './system/SystemUtil';
+export { default as MapTransferUtil } from './transfer/MapTransferUtil';
+export { default as TransferUtil } from './transfer/TransferUtil';
+export { default as UrlUtil } from './url/UrlUtil';

package/esm/number/NumberUtil.d.ts

@@ -0,0 +1,96 @@
+declare namespace NumberUtil {
+    /**
+     * 判断是否为整数
+     * @param {Number} num 数字
+     */
+    const isInteger: (num: number) => boolean;
+    /**
+     * 判断是否为小数
+     * @param {Number} num 数字
+     */
+    const isFloat: (num: number) => boolean;
+    /**
+     * 判断是否是 NaN
+     * @param num 数字
+     */
+    const isaNaN: (num: number) => boolean;
+    /**
+     * 判断是否是有理数
+     * @param num 数字
+     */
+    const isaFinite: (num: number) => boolean;
+    /**
+     * 转为有理数
+     * @param value 要转换的值
+     *
+     * @example
+     *   toFinite(3.2) => 3.2
+     *   toFinite(Infinity) => 1.7976e+308
+     *   toFinite('3.2') => 3.2
+     */
+    const toFinite: (value: any) => number;
+    /**
+     * 检查数字是否在指定区间内
+     * @param num 要检测的数字
+     * @param start 区间的开始，默认值为0
+     * @param end 区间的结束(区间不包含此边界值)
+     * @example
+     * inRange(10,1,100) => true
+     */
+    const inRange: (num: number, start: number, end: number) => boolean;
+    /**
+     * 生成随机数，支持随机整数和随机小数
+     * @param {Number} lower 下边界，默认0
+     * @param {Number} upper 上边界，默认1
+     * @param {Boolean} floating 随机小数的位数，默认为0，即随机整数
+     *
+     * @example
+     *   random(0, 5) => an integer between 0 and 5
+     *   random(5)     => also random(0, 5)
+     *   random(1.2, 5.2, 1) => a floating-point number between 1.2 and 5.2
+     */
+    const random: (lower: number, upper: number, floating?: number) => number;
+    /**
+     * 保留n位小数
+     * @param val 任意类型
+     * @param n 小数位数
+     * @returns 不是string｜number 返回0
+     */
+    function correctNumberInput(val: any, n?: number, type?: "number" | "string"): string | number;
+    /**
+     * 解决两个数相加精度丢失问题
+     * @param a 任意类型
+     * @param b 任意类型
+     * @returns {Number} 错误返回0
+     */
+    function floatAdd(a: any, b: any): number;
+    /**
+     * 解决两个数相减精度丢失问题
+     * @param a 任意类型
+     * @param b 任意类型
+     * @returns {Number}错误返回0
+     */
+    function floatSub(a: any, b: any): number;
+    /**
+     * 解决两个数相乘精度丢失问题
+     * @param a 任意类型
+     * @param b 任意类型
+     * @returns {Number}
+     */
+    function floatMul(a: any, b: any): number;
+    /**
+     * 解决两个数相除精度丢失问题
+     * @param a 任意类型
+     * @param b 任意类型
+     * @returns 错误返回0
+     */
+    function floatDiv(a: any, b: any): number;
+    /**
+     * n在count中的占比%
+     * @param n
+     * @param count
+     * @returns
+     */
+    const number2percentage: (n: number, count: number) => string;
+}
+export default NumberUtil;