a-js-tools 2.0.1 → 2.0.3

package/README.md

@@ -11,16 +11,17 @@ npm install --save a-js-tools
 
 ## 纯函数
 
+- `autoEscapedRegExp` 生成简单的正则表达式
+- `createBezier` 构建简单的贝尔赛曲线
 - `debounce` 防抖函数
-- `throttle` 节流函数
-- `getRandomInt` 获取随机的整数
+- `escapeRegExp` 转义字符串为简单的正则表达式
 - `getRandomFloat` 获取随机的浮点数
+- `getRandomInt` 获取随机的整数
 - `getRandomString` 获取随机字符串
-- `escapeRegExp` 转义字符串为简单的正则表达式
-- `autoEscapedRegExp` 生成简单的正则表达式
 - `isBrowser` 是否为浏览器环境
 - `isNode` 是否为 Node 环境
 - `sleep` 你的线程太累了，让它丫的睡一会吧
+- `throttle` 节流函数
 
 ## class 名称转化
 
@@ -34,7 +35,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 → array/difference.cjs.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/{es/src/array → 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/array/difference.js → array/difference.es.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)) {

package/{cjs/array/index.js → array/index.cjs.js}

@@ -1,30 +1,24 @@
 'use strict';
 
-var intersection = require('./intersection.js');
-var union = require('./union.js');
-var difference = require('./difference.js');
-var symmetricDifference = require('./symmetricDifference.js');
+var intersection = require('./intersection.cjs.js');
+var union = require('./union.cjs.js');
+var difference = require('./difference.cjs.js');
+var symmetricDifference = require('./symmetricDifference.cjs.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/{es/src/array → 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/array/index.js → array/index.es.js}

@@ -1,28 +1,22 @@
-import { intersection } from './intersection.js';
-import { union } from './union.js';
-import { difference } from './difference.js';
-import { symmetricDifference } from './symmetricDifference.js';
+import { intersection } from './intersection.es.js';
+import { union } from './union.es.js';
+import { difference } from './difference.es.js';
+import { symmetricDifference } from './symmetricDifference.es.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/{cjs/array/intersection.js → array/intersection.cjs.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/{es/src/array → 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/array/intersection.js → array/intersection.es.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/{cjs/array/symmetricDifference.js → array/symmetricDifference.cjs.js}

@@ -1,18 +1,15 @@
 'use strict';
 
 var aTypeOfJs = require('a-type-of-js');
-var difference = require('./difference.js');
+var difference = require('./difference.cjs.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/{es/src/array → 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/array/symmetricDifference.js → array/symmetricDifference.es.js}

@@ -1,16 +1,13 @@
 import { isArray, isEmptyArray } from 'a-type-of-js';
-import { difference } from './difference.js';
+import { difference } from './difference.es.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/{cjs/className.js → className.cjs.js}

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