a-js-tools 2.0.1 → 2.0.2

package/README.md

@@ -34,7 +34,3 @@ npm install --save a-js-tools
 - `difference` 方法，计算两个数组的差集（以第一个数组为基准）
 - `symmetricDifference` 方法，计算两个数组的对称差集（在两个数组都不共有的元素）
 - `enArr` 对象，包含上面的方法
-
-## 查看文档
-
-查看 [https://earthnut.dev/npm/a-js-tools](https://earthnut.dev/npm/a-js-tools)

package/cjs/array/difference.js

@@ -3,7 +3,7 @@
 var aTypeOfJs = require('a-type-of-js');
 
 /**
- *  求给出的两个数组的差值（A - B）
+ *  ## 求给出的两个数组的差值（A - B）
  *
  * @param a  - 第一个数组
  * @param b - 第二个数组
@@ -11,13 +11,11 @@ var aTypeOfJs = require('a-type-of-js');
  * @description 当两个参数有一个不是数组时将抛出
  * @returns 返回第一个参数相对第二个参数的差值
  * @example
- *
  * ```ts
  * import { difference} from 'a-js-tools';
  *
  * const log = console.log;
  *
- *
  * log(difference([], [1, 2, 3])); // []
  *
  * log([1, 2, 3], []); //[1, 2, 3]
@@ -31,7 +29,6 @@ var aTypeOfJs = require('a-type-of-js');
  * log(difference([1, 2, 3], null));
  * log(difference([1, 2, 3],  true));
  * ```
- *
  */
 function difference(a, b) {
     if (!aTypeOfJs.isArray(a) || !aTypeOfJs.isArray(b)) {

package/cjs/array/index.js

@@ -6,25 +6,19 @@ var difference = require('./difference.js');
 var symmetricDifference = require('./symmetricDifference.js');
 
 /**
+ * ## 数组的一些方法
  *
- * 数组的一些方法
- *
- * - union 两个数组的并集（排除共有项）
- * - intersection 两个数组的交集（共有项）
- * - difference 两个数组的差集 （A - B）
- * - symmetricDifference  对称差集 （ A △ B）
- *
+ * - `union` 两个数组的并集（排除共有项）
+ * - `intersection` 两个数组的交集（共有项）
+ * - `difference` 两个数组的差集 （A - B）
+ * - `symmetricDifference`  对称差集 （ A △ B）
  */
 const enArr = {
     /**
-     *
-     * 数组的并集
-     *
+     * ### 数组的并集
      *  <span style="color:#f36;">请注意，参数有不为数组时直接抛出 TypeError</span>
      * @param arrays  - 多个数组
      * @returns 联合后的数组
-     *
-     *
      * @example
      *
      * ```ts
@@ -55,33 +49,27 @@ const enArr = {
      * // [1, 2, 3, 4, 6]
      * log(union([1, 2, 3], [2, 4, 6], [1, 2, 3], [1, 2, 3]));
      * ```
-     *
      */
     union: union.union,
     /**
-     *
-     * 两个数组的交集
+     * ### 两个数组的交集
      *
      * @param a 数组 1️⃣
      * @param b 数组 2️⃣
      * @returns 返回两个数组的交集
      * @example
-     *
      * ```ts
      * import { intersection } from 'a-js-tools';
      *
      * const log = console.log;
      *
-     *
      * log(intersection([1, 2, 3, 4], [2, 3])); // [2, 3]
      * log(intersection([1, 3, 5, 7], [2, 3, 4])); // [3]
-     *
      * ```
-     *
      */
     intersection: intersection.intersection,
     /**
-     *  求给出的两个数组的差值（A - B）
+     * ### 求给出的两个数组的差值（A - B）
      *
      * @param a  - 第一个数组
      * @param b - 第二个数组
@@ -89,13 +77,11 @@ const enArr = {
      * @description 当两个参数有一个不是数组时将抛出
      * @returns 返回第一个参数相对第二个参数的差值
      * @example
-     *
      * ```ts
      * import { difference} from 'a-js-tools';
      *
      * const log = console.log;
      *
-     *
      * log(difference([], [1, 2, 3])); // []
      *
      * log([1, 2, 3], []); //[1, 2, 3]
@@ -109,19 +95,15 @@ const enArr = {
      * log(difference([1, 2, 3], null));
      * log(difference([1, 2, 3],  true));
      * ```
-     *
      */
     difference: difference.difference,
     /**
-     *
-     * 对称差集 （ A △ B）
+     * ### 对称差集 （ A △ B）
      *
      * @param a  - 数组 a
      * @param b  - 数组 b
      * @returns - 返回一个全新的数组
-     *
      * @example
-     *
      * ```ts
      * import { symmetricDifference } from 'a-js-tools';
      *
@@ -133,16 +115,13 @@ const enArr = {
      *
      * log(symmetricDifference([1, 2, 3], [1, 2, 3])); // []
      *
-     *
      * /// TypeError
      * log(symmetricDifference(1, []));
      * log(symmetricDifference(undefined, []));
      * log(symmetricDifference(null, []));
      * log(symmetricDifference('a', []));
      * log(symmetricDifference(true, []));
-     *
      * ```
-     *
      */
     symmetricDifference: symmetricDifference.symmetricDifference,
 };

package/cjs/array/intersection.js

@@ -3,25 +3,20 @@
 var aTypeOfJs = require('a-type-of-js');
 
 /**
- *
- * 两个数组的交集
+ * ## 两个数组的交集
  *
  * @param a 数组 1️⃣
  * @param b 数组 2️⃣
  * @returns 返回两个数组的交集
  * @example
- *
  * ```ts
  * import { intersection } from 'a-js-tools';
  *
  * const log = console.log;
  *
- *
  * log(intersection([1, 2, 3, 4], [2, 3])); // [2, 3]
  * log(intersection([1, 3, 5, 7], [2, 3, 4])); // [3]
- *
  * ```
- *
  */
 function intersection(a, b) {
     if (!aTypeOfJs.isArray(a) || !aTypeOfJs.isArray(b)) {

package/cjs/array/symmetricDifference.js

@@ -4,15 +4,12 @@ var aTypeOfJs = require('a-type-of-js');
 var difference = require('./difference.js');
 
 /**
- *
- * 对称差集 （ A △ B）
+ * ## 对称差集 （ A △ B）
  *
  * @param a  - 数组 a
  * @param b  - 数组 b
  * @returns - 返回一个全新的数组
- *
  * @example
- *
  * ```ts
  * import { symmetricDifference } from 'a-js-tools';
  *
@@ -24,16 +21,13 @@ var difference = require('./difference.js');
  *
  * log(symmetricDifference([1, 2, 3], [1, 2, 3])); // []
  *
- *
  * /// TypeError
  * log(symmetricDifference(1, []));
  * log(symmetricDifference(undefined, []));
  * log(symmetricDifference(null, []));
  * log(symmetricDifference('a', []));
  * log(symmetricDifference(true, []));
- *
  * ```
- *
  */
 function symmetricDifference(a, b) {
     if (!aTypeOfJs.isArray(a) || !aTypeOfJs.isArray(b)) {

package/cjs/className.js

@@ -2,10 +2,6 @@
 
 /**
  * 驼峰命名与连字符命名法的互换
- *
- * @packageDocumentation
- * @module @a-js-tools/class-name
- * @license MIT
  */
 /**
  *

package/cjs/getRandomNumber.js

@@ -3,15 +3,10 @@
 var aTypeOfJs = require('a-type-of-js');
 
 /**
- * 过去随机数
- *
- * @packageDocumentation
- * @module @a-js-tools/get-random-number
- * @license MIT
+ * 获取随机数
  */
 /**
- *
- * 获取一个随机的整数类型
+ * ## 获取一个随机的整数类型
  *
  * 您可以传入两个参数并获取它们之间的任意数字，返回值<span style="color:#ff0;">*会包含端值*</span>
  *
@@ -44,8 +39,7 @@ function getRandomInt(max = 1, min = 0) {
     return Math.round(Math.random() * (_max - _min) + _min);
 }
 /**
- *
- * 获取任意的浮点数
+ * ## 获取任意的浮点数
  *
  * 您可以传入两个参数并获取它们之间的任意数字
  *

package/cjs/getRandomString.js

@@ -6,19 +6,20 @@ var getRandomNumber = require('./getRandomNumber.js');
 
 /**
  * 获取随机字符串
- *
- * @packageDocumentation
- * @module @a-js-tools/get-random-string
- * @license MIT
  */
 /**
+ * 获取简单的随机字符串
  *
- *  获取简单的随机字符串
- *
- *  @param   options - 字符串长度
- *  @returns  - 随机字符串
- *
+ * @param  options - 字符串生成参数
+ * @returns  - 随机字符串
+ * @example
+ * ```ts
+ * import { getRandomString } from 'a-js-tools';
  *
+ * // 获取简单的随机字符串
+ * // 'abcdefg'
+ * // getRandomString(7);
+ * ```
  */
 function getRandomString(options) {
     //   验证输入参数
@@ -90,18 +91,17 @@ function getRandomString(options) {
             result += str[getRandomNumber.getRandomInt(strLen - 1)];
     }
     /**
+     * ## 字符串交叉函数
      *
-     *  字符串交叉函数
-     *
-     *  非线形串交叉，对相交叉
+     * 非线形串交叉，对相交叉
      *
-     *  @param  str1 - 字符串1
-     *  @param  str2 - 字符串2
-     *  @returns - 交叉后的字符串
-     *  @example
-     *  ```ts
-     *  interleaveString('abc', '123') // 'a1b2c3'
-     *  ```
+     * @param  str1 - 字符串1
+     * @param  str2 - 字符串2
+     * @returns - 交叉后的字符串
+     * @example
+     * ```ts
+     * interleaveString('abc', '123') // 'a1b2c3'
+     * ```
      */
     function interleaveString(str1, str2) {
         const str1Length = str1.length, str2Length = str2.length;

package/cjs/index.js

@@ -10,10 +10,10 @@ var autoEscapedRegExp = require('./regexp/autoEscapedRegExp.js');
 var isNode = require('./isNode.js');
 var index = require('./array/index.js');
 var sleep = require('./sleep.js');
-var intersection = require('./array/intersection.js');
-var union = require('./array/union.js');
 var difference = require('./array/difference.js');
+var intersection = require('./array/intersection.js');
 var symmetricDifference = require('./array/symmetricDifference.js');
+var union = require('./array/union.js');
 
 
 
@@ -32,7 +32,7 @@ exports.isBrowser = isNode.isBrowser;
 exports.isNode = isNode.isNode;
 exports.enArr = index.enArr;
 exports.sleep = sleep.sleep;
-exports.intersection = intersection.intersection;
-exports.union = union.union;
 exports.difference = difference.difference;
+exports.intersection = intersection.intersection;
 exports.symmetricDifference = symmetricDifference.symmetricDifference;
+exports.union = union.union;

package/cjs/isNode.js

@@ -3,9 +3,7 @@
 var aTypeOfJs = require('a-type-of-js');
 
 /**
- *
  * 判断当前环境是否为 node 环境
- *
  */
 function isNode() {
     return !aTypeOfJs.isUndefined((globalThis &&
@@ -15,9 +13,7 @@ function isNode() {
         undefined);
 }
 /**
- *
  * 是否为浏览器环境
- *
  */
 function isBrowser() {
     return !isNode();

package/cjs/object/createConstructor.js

@@ -1,8 +1,7 @@
 'use strict';
 
 /**
- *
- * 构建一个 Constructor 构造函数
+ * # 构建一个 Constructor 构造函数
  *
  * 接收一个构造函数，然后返回 TS 能识别的构造函数自身
  *
@@ -12,7 +11,7 @@
  *
  * @param constructor - 传入一个构造函数
  * @returns 返回传入的构造函数
- *
+ * @example
  * ```ts
  * import { createConstructor } from "a-js-tools";
  *
@@ -33,9 +32,7 @@
  * const tomConstructor = createConstructor(_tom);
  *
  * const b = new tomConstructor(); // 这时就不会显示错误
- *
  * ```
- *
  */
 function createConstructor(constructor) {
     constructor.prototype.apply = Function.apply;

package/cjs/performance.js

@@ -1,18 +1,11 @@
 'use strict';
 
 var aTypeOfJs = require('a-type-of-js');
-var isFunction = require('a-type-of-js/isFunction');
-var isNumber = require('a-type-of-js/isNumber');
 
 /**
  * 防抖和节流
- *
- * @packageDocumentation
- * @module @a-js-tools/performance
- * @license MIT
  */
 /**
- *
  * 防抖
  *
  * @param   callback 回调函数
@@ -23,16 +16,15 @@ var isNumber = require('a-type-of-js/isNumber');
  * ```ts
  * const debounce = (callback: Function, delay = 300) => {
  *   let timer: any = null
- *   return (...args: any[]) => {
- *     clearTimeout(timer)
- *   }
- * }
  *
+ *   return (...args: any[]) => clearTimeout(timer)
+ * }
+ * ```
  */
 function debounce(callback, options = 200) {
-    if (!isFunction.isFunction(callback))
+    if (!aTypeOfJs.isFunction(callback))
         throw new TypeError('callback must be a function');
-    if (isNumber.isNumber(options))
+    if (aTypeOfJs.isNumber(options))
         options = {
             delay: options,
             this: null,
@@ -68,16 +60,16 @@ function debounce(callback, options = 200) {
     return result;
 }
 /**
- *   节流
+ * 节流
  *
  * @param callback   回调函数
  * @param options      延迟时间（毫秒），默认 200 (ms) 或设置 this
  * @returns   返回的闭包函数
  */
 function throttle(callback, options = 200) {
-    if (!isFunction.isFunction(callback))
+    if (!aTypeOfJs.isFunction(callback))
         throw new TypeError('callback must be a function');
-    if (isNumber.isNumber(options))
+    if (aTypeOfJs.isNumber(options))
         options = {
             delay: options,
             this: null,

package/cjs/regexp/autoEscapedRegExp.js

@@ -5,8 +5,7 @@ var escapeRegExp = require('./escapeRegExp.js');
 var parse = require('./parse.js');
 
 /**
- *
- * ##  适用于简单的文本字符串自动转化为简单模式正则表达式
+ * ## 适用于简单的文本字符串自动转化为简单模式正则表达式
  *
  * *若字符串包含且需保留字符类、组、反向引用、量词等时，该方法可能不适用*
  *
@@ -14,7 +13,6 @@ var parse = require('./parse.js');
  * @param options 转化选项。 为文本字符串时，默认为正则表达式的标志，还可指定是否匹配开头或结尾
  * @returns 正则表达式
  * @example
- *
  * ```ts
  * import { autoEscapedRegExp } from 'a-regexp';
  *
@@ -30,9 +28,7 @@ var parse = require('./parse.js');
  * autoEscapedRegExp('a-zA-Z0-9', 'g'); // => /a-zA-Z0-9/g
  * autoEscapedRegExp('[a-zA-Z0-9]'); // => /\[a-zA-Z0-9\]/
  * autoEscapedRegExp('^[a-zA-Z0-9]+$'); // => /\^\[a-zA-Z0-9\]\$/
- *
  * ```
- *
  */
 function autoEscapedRegExp(pattern, options) {
     if (!aTypeOfJs.isString(pattern))

package/cjs/regexp/escapeRegExp.js

@@ -1,20 +1,18 @@
 'use strict';
 
 /**
- *
- * 将一个字符串转化为符合正则要求的字符串
+ * # 将一个字符串转化为符合正则要求的字符串
  *
  * @param str 需要转义的字符串
  * @requires escapeRegExp 转化后字符串
  * @example
- *
  * ```ts
- *  import { escapeRegExp  } from 'a-js-tools';
+ * import { escapeRegExp  } from 'a-js-tools';
  *
- *  escapeRegExp('a.b.c'); // 'a\\.b\\.c'
- *  escapeRegExp('a\\.b\\.c'); // 'a\\\\.b\\\\.c'
- *  escapeRegExp('[a-z]'); // '\\[a-z\\]'
- *  escapeRegExp('^abc$'); // '\\^abc\\$'
+ * escapeRegExp('a.b.c'); // 'a\\.b\\.c'
+ * escapeRegExp('a\\.b\\.c'); // 'a\\\\.b\\\\.c'
+ * escapeRegExp('[a-z]'); // '\\[a-z\\]'
+ * escapeRegExp('^abc$'); // '\\^abc\\$'
  * ```
  */
 function escapeRegExp(str) {

package/cjs/regexp/parse.js

@@ -3,9 +3,7 @@
 var aTypeOfJs = require('a-type-of-js');
 
 /**
- *
  * 解析 options
- *
  */
 function parse(options) {
     // 处理 options

package/cjs/sleep.js

@@ -1,9 +1,8 @@
 'use strict';
 
-var isNumber = require('a-type-of-js/isNumber');
+var aTypeOfJs = require('a-type-of-js');
 
 /**
- *
  * ## 线程休息
  *
  * 但从调用到执行完毕总是与期望的时间并不相吻合，除非执行是线型的（也不保证时间的严格性）
@@ -23,14 +22,12 @@ var isNumber = require('a-type-of-js/isNumber');
  * console.log(Date.now()); // 1748058118471
  * await sleep(1000);
  * console.log(Date.now()); // 1748058119473
- *
  * ```
- *
  */
 async function sleep(delay = 1000) {
-    if (!isFinite(delay) || delay < 0)
+    if (!isFinite(delay) || delay < 4)
         throw new TypeError('delay 应该是一个正常的数值');
-    if (isNumber.isZero(delay))
+    if (aTypeOfJs.isZero(delay))
         return Promise.resolve();
     return new Promise(resolve => setTimeout(resolve, delay));
 }

package/es/array/difference.js

@@ -1,7 +1,7 @@
 import { isArray, isEmptyArray } from 'a-type-of-js';
 
 /**
- *  求给出的两个数组的差值（A - B）
+ *  ## 求给出的两个数组的差值（A - B）
  *
  * @param a  - 第一个数组
  * @param b - 第二个数组
@@ -9,13 +9,11 @@ import { isArray, isEmptyArray } from 'a-type-of-js';
  * @description 当两个参数有一个不是数组时将抛出
  * @returns 返回第一个参数相对第二个参数的差值
  * @example
- *
  * ```ts
  * import { difference} from 'a-js-tools';
  *
  * const log = console.log;
  *
- *
  * log(difference([], [1, 2, 3])); // []
  *
  * log([1, 2, 3], []); //[1, 2, 3]
@@ -29,7 +27,6 @@ import { isArray, isEmptyArray } from 'a-type-of-js';
  * log(difference([1, 2, 3], null));
  * log(difference([1, 2, 3],  true));
  * ```
- *
  */
 function difference(a, b) {
     if (!isArray(a) || !isArray(b)) {