a-js-tools 2.0.0 → 2.0.2

package/es/array/index.js

@@ -4,25 +4,19 @@ import { difference } from './difference.js';
 import { symmetricDifference } from './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
@@ -53,33 +47,27 @@ const enArr = {
      * // [1, 2, 3, 4, 6]
      * log(union([1, 2, 3], [2, 4, 6], [1, 2, 3], [1, 2, 3]));
      * ```
-     *
      */
     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,
     /**
-     *  求给出的两个数组的差值（A - B）
+     * ### 求给出的两个数组的差值（A - B）
      *
      * @param a  - 第一个数组
      * @param b - 第二个数组
@@ -87,13 +75,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]
@@ -107,19 +93,15 @@ const enArr = {
      * log(difference([1, 2, 3], null));
      * log(difference([1, 2, 3],  true));
      * ```
-     *
      */
     difference,
     /**
-     *
-     * 对称差集 （ A △ B）
+     * ### 对称差集 （ A △ B）
      *
      * @param a  - 数组 a
      * @param b  - 数组 b
      * @returns - 返回一个全新的数组
-     *
      * @example
-     *
      * ```ts
      * import { symmetricDifference } from 'a-js-tools';
      *
@@ -131,16 +113,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,
 };

package/es/array/intersection.js

@@ -1,25 +1,20 @@
 import { isArray, isEmptyArray } from '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 (!isArray(a) || !isArray(b)) {

package/es/array/symmetricDifference.js

@@ -2,15 +2,12 @@ import { isArray, isEmptyArray } from 'a-type-of-js';
 import { difference } from './difference.js';
 
 /**
- *
- * 对称差集 （ A △ B）
+ * ## 对称差集 （ A △ B）
  *
  * @param a  - 数组 a
  * @param b  - 数组 b
  * @returns - 返回一个全新的数组
- *
  * @example
- *
  * ```ts
  * import { symmetricDifference } from 'a-js-tools';
  *
@@ -22,16 +19,13 @@ import { difference } from './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 (!isArray(a) || !isArray(b)) {

package/es/className.js

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

package/es/getRandomNumber.js

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

package/es/getRandomString.js

@@ -4,19 +4,20 @@ import { getRandomInt } from './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) {
     //   验证输入参数
@@ -88,18 +89,17 @@ function getRandomString(options) {
             result += str[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/es/index.js

@@ -8,7 +8,7 @@ export { autoEscapedRegExp } from './regexp/autoEscapedRegExp.js';
 export { isBrowser, isNode } from './isNode.js';
 export { enArr } from './array/index.js';
 export { sleep } from './sleep.js';
-export { intersection } from './array/intersection.js';
-export { union } from './array/union.js';
 export { difference } from './array/difference.js';
+export { intersection } from './array/intersection.js';
 export { symmetricDifference } from './array/symmetricDifference.js';
+export { union } from './array/union.js';

package/es/isNode.js

@@ -1,9 +1,7 @@
 import { isUndefined } from 'a-type-of-js';
 
 /**
- *
  * 判断当前环境是否为 node 环境
- *
  */
 function isNode() {
     return !isUndefined((globalThis &&
@@ -13,9 +11,7 @@ function isNode() {
         undefined);
 }
 /**
- *
  * 是否为浏览器环境
- *
  */
 function isBrowser() {
     return !isNode();

package/es/object/createConstructor.js

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

package/es/performance.js

@@ -1,16 +1,9 @@
-import { isUndefined, isNull } from 'a-type-of-js';
-import { isFunction } from 'a-type-of-js/isFunction';
-import { isNumber } from 'a-type-of-js/isNumber';
+import { isFunction, isNumber, isUndefined, isNull } from 'a-type-of-js';
 
 /**
  * 防抖和节流
- *
- * @packageDocumentation
- * @module @a-js-tools/performance
- * @license MIT
  */
 /**
- *
  * 防抖
  *
  * @param   callback 回调函数
@@ -21,11 +14,10 @@ import { isNumber } from '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(callback))
@@ -66,7 +58,7 @@ function debounce(callback, options = 200) {
     return result;
 }
 /**
- *   节流
+ * 节流
  *
  * @param callback   回调函数
  * @param options      延迟时间（毫秒），默认 200 (ms) 或设置 this

package/es/regexp/autoEscapedRegExp.js

@@ -3,8 +3,7 @@ import { escapeRegExp } from './escapeRegExp.js';
 import { parse } from './parse.js';
 
 /**
- *
- * ##  适用于简单的文本字符串自动转化为简单模式正则表达式
+ * ## 适用于简单的文本字符串自动转化为简单模式正则表达式
  *
  * *若字符串包含且需保留字符类、组、反向引用、量词等时，该方法可能不适用*
  *
@@ -12,7 +11,6 @@ import { parse } from './parse.js';
  * @param options 转化选项。 为文本字符串时，默认为正则表达式的标志，还可指定是否匹配开头或结尾
  * @returns 正则表达式
  * @example
- *
  * ```ts
  * import { autoEscapedRegExp } from 'a-regexp';
  *
@@ -28,9 +26,7 @@ import { parse } from './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 (!isString(pattern))

package/es/regexp/escapeRegExp.js

@@ -1,18 +1,16 @@
 /**
- *
- * 将一个字符串转化为符合正则要求的字符串
+ * # 将一个字符串转化为符合正则要求的字符串
  *
  * @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/es/regexp/parse.js

@@ -1,9 +1,7 @@
 import { isString, isNull } from 'a-type-of-js';
 
 /**
- *
  * 解析 options
- *
  */
 function parse(options) {
     // 处理 options

package/es/sleep.js

@@ -1,7 +1,6 @@
-import { isZero } from 'a-type-of-js/isNumber';
+import { isZero } from 'a-type-of-js';
 
 /**
- *
  * ## 线程休息
  *
  * 但从调用到执行完毕总是与期望的时间并不相吻合，除非执行是线型的（也不保证时间的严格性）
@@ -21,12 +20,10 @@ import { isZero } from '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 (isZero(delay))
         return Promise.resolve();

package/es/{src → types}/array/difference.d.ts

@@ -1,5 +1,5 @@
 /**
- *  求给出的两个数组的差值（A - B）
+ *  ## 求给出的两个数组的差值（A - B）
  *
  * @param a  - 第一个数组
  * @param b - 第二个数组
@@ -7,13 +7,11 @@
  * @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]
@@ -27,6 +25,5 @@
  * log(difference([1, 2, 3], null));
  * log(difference([1, 2, 3],  true));
  * ```
- *
  */
 export declare function difference<T>(a: T[], b: T[]): T[];

package/es/{src → types}/array/index.d.ts

@@ -4,25 +4,19 @@ import { difference } from './difference';
 import { symmetricDifference } from './symmetricDifference';
 export { union, intersection, difference, symmetricDifference };
 /**
+ * ## 数组的一些方法
  *
- * 数组的一些方法
- *
- * - union 两个数组的并集（排除共有项）
- * - intersection 两个数组的交集（共有项）
- * - difference 两个数组的差集 （A - B）
- * - symmetricDifference  对称差集 （ A △ B）
- *
+ * - `union` 两个数组的并集（排除共有项）
+ * - `intersection` 两个数组的交集（共有项）
+ * - `difference` 两个数组的差集 （A - B）
+ * - `symmetricDifference`  对称差集 （ A △ B）
  */
 export declare const enArr: {
     /**
-     *
-     * 数组的并集
-     *
+     * ### 数组的并集
      *  <span style="color:#f36;">请注意，参数有不为数组时直接抛出 TypeError</span>
      * @param arrays  - 多个数组
      * @returns 联合后的数组
-     *
-     *
      * @example
      *
      * ```ts
@@ -53,33 +47,27 @@ export declare const enArr: {
      * // [1, 2, 3, 4, 6]
      * log(union([1, 2, 3], [2, 4, 6], [1, 2, 3], [1, 2, 3]));
      * ```
-     *
      */
     union: typeof 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: typeof intersection;
     /**
-     *  求给出的两个数组的差值（A - B）
+     * ### 求给出的两个数组的差值（A - B）
      *
      * @param a  - 第一个数组
      * @param b - 第二个数组
@@ -87,13 +75,11 @@ export declare 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]
@@ -107,19 +93,15 @@ export declare const enArr: {
      * log(difference([1, 2, 3], null));
      * log(difference([1, 2, 3],  true));
      * ```
-     *
      */
     difference: typeof difference;
     /**
-     *
-     * 对称差集 （ A △ B）
+     * ### 对称差集 （ A △ B）
      *
      * @param a  - 数组 a
      * @param b  - 数组 b
      * @returns - 返回一个全新的数组
-     *
      * @example
-     *
      * ```ts
      * import { symmetricDifference } from 'a-js-tools';
      *
@@ -131,16 +113,13 @@ export declare 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: typeof symmetricDifference;
 };

package/es/{src → types}/array/intersection.d.ts

@@ -1,22 +1,17 @@
 /**
- *
- * 两个数组的交集
+ * ## 两个数组的交集
  *
  * @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]
- *
  * ```
- *
  */
 export declare function intersection<T>(a: T[], b: T[]): T[];

package/es/{src → types}/array/symmetricDifference.d.ts

@@ -1,13 +1,10 @@
 /**
- *
- * 对称差集 （ A △ B）
+ * ## 对称差集 （ A △ B）
  *
  * @param a  - 数组 a
  * @param b  - 数组 b
  * @returns - 返回一个全新的数组
- *
  * @example
- *
  * ```ts
  * import { symmetricDifference } from 'a-js-tools';
  *
@@ -19,15 +16,12 @@
  *
  * log(symmetricDifference([1, 2, 3], [1, 2, 3])); // []
  *
- *
  * /// TypeError
  * log(symmetricDifference(1, []));
  * log(symmetricDifference(undefined, []));
  * log(symmetricDifference(null, []));
  * log(symmetricDifference('a', []));
  * log(symmetricDifference(true, []));
- *
  * ```
- *
  */
 export declare function symmetricDifference<T>(a: T[], b: T[]): T[];

package/es/{src → types}/className.d.ts

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