@mudbean/utils 2.0.5

package/cjs/regexp/parse.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var is = require('@mudbean/is');
+
+/**
+ * # 解析 options
+ * @param options
+ */
+function parse(options) {
+    // 处理 options
+    if (is.isString(options)) {
+        options = {
+            flags: options,
+        };
+    }
+    // 处理 flags
+    if (!is.isString(options.flags))
+        options.flags = '';
+    else {
+        // 需求是保留字符串中的某一部分，使用
+        const regexp = /[migsuy]/g;
+        const matchResult = options.flags.match(regexp);
+        if (is.isNull(matchResult))
+            options.flags = '';
+        else
+            options.flags = [...new Set(matchResult)].join('');
+    }
+    return options;
+}
+
+exports.parse = parse;

package/cjs/sleep.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var is = require('@mudbean/is');
+
+/**
+ * # 线程休息
+ *
+ * 但从调用到执行完毕总是与期望的时间并不相吻合，除非执行是线型的（也不保证时间的严格性）
+ *
+ * - 宏任务：整体代码、setTimeout、DOM 事件回调、requestAnimationFrame、setImmediate、setInterval、I/O操作、UI渲染等
+ * - 微任务：Promise的then/catch/finally、process.nextTick（Node.js）、MutationObserver、queueMicrotask（显示添加微任务）等
+ *
+ * <span style="color:#ff0;">*Node.js 中的 process.nextTick 优先级高于其他微任务*</span>
+ *
+ * *如果参数为非法数值，将会抛出 TypeError *
+ *
+ * @param delay 睡觉时长（机器时间，毫秒为单位）
+ * @returns 🈳
+ * @example
+ *
+ * ```ts
+ * import { sleep } from '@mudbean/utils';
+ *
+ * console.log(Date.now()); // 1748058118471
+ * await sleep(1000);
+ * console.log(Date.now()); // 1748058119473
+ * ```
+ */
+async function sleep(delay = 1000) {
+    if (!isFinite(delay) || delay < 4)
+        throw new TypeError('delay 应该是一个正常的数值');
+    if (is.isZero(delay))
+        return Promise.resolve();
+    return new Promise(resolve => setTimeout(resolve, delay));
+}
+
+exports.sleep = sleep;

package/es/array/difference.d.ts

@@ -0,0 +1,29 @@
+/**
+ *  ## 求给出的两个数组的差值（A - B）
+ *
+ * @param a  - 第一个数组
+ * @param b - 第二个数组
+ * @throws {TypeError} 当两个参数有一个不是
+ * @description 当两个参数有一个不是数组时将抛出
+ * @returns 返回第一个参数相对第二个参数的差值
+ * @example
+ * ```ts
+ * import { difference} from '@mudbean/utils';
+ *
+ * const log = console.log;
+ *
+ * log(difference([], [1, 2, 3])); // []
+ *
+ * log([1, 2, 3], []); //[1, 2, 3]
+ *
+ * log([1, 2, 3, 4, 5, 6, 7], [1, 2, 3, 4, 5]); //[6, 7]
+ *
+ * // 将抛出 TypeError
+ * log(difference([1, 2, 3], 'a'));
+ * log(difference([1, 2, 3], 1));
+ * log(difference([1, 2, 3], undefined));
+ * 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

@@ -0,0 +1,46 @@
+import { isArray, isEmptyArray } from '@mudbean/is';
+
+/**
+ *  ## 求给出的两个数组的差值（A - B）
+ *
+ * @param a  - 第一个数组
+ * @param b - 第二个数组
+ * @throws {TypeError} 当两个参数有一个不是
+ * @description 当两个参数有一个不是数组时将抛出
+ * @returns 返回第一个参数相对第二个参数的差值
+ * @example
+ * ```ts
+ * import { difference} from '@mudbean/utils';
+ *
+ * const log = console.log;
+ *
+ * log(difference([], [1, 2, 3])); // []
+ *
+ * log([1, 2, 3], []); //[1, 2, 3]
+ *
+ * log([1, 2, 3, 4, 5, 6, 7], [1, 2, 3, 4, 5]); //[6, 7]
+ *
+ * // 将抛出 TypeError
+ * log(difference([1, 2, 3], 'a'));
+ * log(difference([1, 2, 3], 1));
+ * log(difference([1, 2, 3], undefined));
+ * log(difference([1, 2, 3], null));
+ * log(difference([1, 2, 3],  true));
+ * ```
+ */
+function difference(a, b) {
+    if (!isArray(a) || !isArray(b)) {
+        throw new TypeError('参数需为数组');
+    }
+    if (isEmptyArray(a) || isEmptyArray(b)) {
+        return a;
+    }
+    /**  获取两个数组中长度较小的  */
+    // 参数有顺序要求
+    // const [shorter, longer] = a.length > b.length ? [b, a] : [a, b];
+    // const shorterSet = new Set(shorter);
+    const bSet = new Set(b);
+    return a.filter(i => !bSet.has(i));
+}
+
+export { difference };

package/es/array/index.d.ts

@@ -0,0 +1,125 @@
+import { intersection } from './intersection';
+import { union } from './union';
+import { difference } from './difference';
+import { symmetricDifference } from './symmetricDifference';
+export { union, intersection, difference, symmetricDifference };
+/**
+ * # 数组的一些方法
+ *
+ * - `union` 两个数组的并集（排除共有项）
+ * - `intersection` 两个数组的交集（共有项）
+ * - `difference` 两个数组的差集 （A - B）
+ * - `symmetricDifference`  对称差集 （ A △ B）
+ */
+export declare const enArr: {
+    /**
+     * ## 数组的并集
+     *  <span style="color:#f36;">请注意，参数有不为数组时直接抛出 TypeError</span>
+     * @param arrays  - 多个数组
+     * @returns 联合后的数组
+     * @example
+     *
+     * ```ts
+     * import { union } from '@mudbean/utils';
+     *
+     * const log = console.log;
+     *
+     * // []
+     * log(union());
+     *
+     * // [1, 2, 3]
+     * log(union([1, 2, 3]));
+     *
+     * //  TypeError
+     * log(union([1, 2, 3], 'i'));
+     * log(union([1, 2, 3], undefined));
+     * log(union([1, 2, 3], null));
+     * log(union([1, 2, 3], 4));
+     * log(union([1, 2, 3], {}));
+     * log(union([1, 2, 3], false));
+     *
+     * // [1, 2, 3, 4, 6]
+     * log(union([1, 2, 3], [2, 4, 6]));
+     *
+     * // [1, 2, 3, 4, 6]
+     * log(union([1, 2, 3], [2, 4, 6], [1, 2, 3]));
+     *
+     * // [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 '@mudbean/utils';
+     *
+     * 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）
+     *
+     * @param a  - 第一个数组
+     * @param b - 第二个数组
+     * @throws {TypeError} 当两个参数有一个不是
+     * @description 当两个参数有一个不是数组时将抛出
+     * @returns 返回第一个参数相对第二个参数的差值
+     * @example
+     * ```ts
+     * import { difference} from '@mudbean/utils';
+     *
+     * const log = console.log;
+     *
+     * log(difference([], [1, 2, 3])); // []
+     *
+     * log([1, 2, 3], []); //[1, 2, 3]
+     *
+     * log([1, 2, 3, 4, 5, 6, 7], [1, 2, 3, 4, 5]); //[6, 7]
+     *
+     * // 将抛出 TypeError
+     * log(difference([1, 2, 3], 'a'));
+     * log(difference([1, 2, 3], 1));
+     * log(difference([1, 2, 3], undefined));
+     * log(difference([1, 2, 3], null));
+     * log(difference([1, 2, 3],  true));
+     * ```
+     */
+    difference: typeof difference;
+    /**
+     * ## 对称差集 （ A △ B）
+     *
+     * @param a  - 数组 a
+     * @param b  - 数组 b
+     * @returns - 返回一个全新的数组
+     * @example
+     * ```ts
+     * import { symmetricDifference } from '@mudbean/utils';
+     *
+     * const log = console.log;
+     *
+     * log(symmetricDifference([1, 2], [2, 3])); // [1, 3]
+     *
+     * log(symmetricDifference([1, 2, 3], [1, 2, 4])); // [3, 4]
+     *
+     * 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

@@ -0,0 +1,127 @@
+import { intersection } from './intersection.js';
+import { union } from './union.js';
+import { difference } from './difference.js';
+import { symmetricDifference } from './symmetricDifference.js';
+
+/**
+ * # 数组的一些方法
+ *
+ * - `union` 两个数组的并集（排除共有项）
+ * - `intersection` 两个数组的交集（共有项）
+ * - `difference` 两个数组的差集 （A - B）
+ * - `symmetricDifference`  对称差集 （ A △ B）
+ */
+const enArr = {
+    /**
+     * ## 数组的并集
+     *  <span style="color:#f36;">请注意，参数有不为数组时直接抛出 TypeError</span>
+     * @param arrays  - 多个数组
+     * @returns 联合后的数组
+     * @example
+     *
+     * ```ts
+     * import { union } from '@mudbean/utils';
+     *
+     * const log = console.log;
+     *
+     * // []
+     * log(union());
+     *
+     * // [1, 2, 3]
+     * log(union([1, 2, 3]));
+     *
+     * //  TypeError
+     * log(union([1, 2, 3], 'i'));
+     * log(union([1, 2, 3], undefined));
+     * log(union([1, 2, 3], null));
+     * log(union([1, 2, 3], 4));
+     * log(union([1, 2, 3], {}));
+     * log(union([1, 2, 3], false));
+     *
+     * // [1, 2, 3, 4, 6]
+     * log(union([1, 2, 3], [2, 4, 6]));
+     *
+     * // [1, 2, 3, 4, 6]
+     * log(union([1, 2, 3], [2, 4, 6], [1, 2, 3]));
+     *
+     * // [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 '@mudbean/utils';
+     *
+     * 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）
+     *
+     * @param a  - 第一个数组
+     * @param b - 第二个数组
+     * @throws {TypeError} 当两个参数有一个不是
+     * @description 当两个参数有一个不是数组时将抛出
+     * @returns 返回第一个参数相对第二个参数的差值
+     * @example
+     * ```ts
+     * import { difference} from '@mudbean/utils';
+     *
+     * const log = console.log;
+     *
+     * log(difference([], [1, 2, 3])); // []
+     *
+     * log([1, 2, 3], []); //[1, 2, 3]
+     *
+     * log([1, 2, 3, 4, 5, 6, 7], [1, 2, 3, 4, 5]); //[6, 7]
+     *
+     * // 将抛出 TypeError
+     * log(difference([1, 2, 3], 'a'));
+     * log(difference([1, 2, 3], 1));
+     * log(difference([1, 2, 3], undefined));
+     * log(difference([1, 2, 3], null));
+     * log(difference([1, 2, 3],  true));
+     * ```
+     */
+    difference,
+    /**
+     * ## 对称差集 （ A △ B）
+     *
+     * @param a  - 数组 a
+     * @param b  - 数组 b
+     * @returns - 返回一个全新的数组
+     * @example
+     * ```ts
+     * import { symmetricDifference } from '@mudbean/utils';
+     *
+     * const log = console.log;
+     *
+     * log(symmetricDifference([1, 2], [2, 3])); // [1, 3]
+     *
+     * log(symmetricDifference([1, 2, 3], [1, 2, 4])); // [3, 4]
+     *
+     * 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,
+};
+
+export { difference, enArr, intersection, symmetricDifference, union };

package/es/array/intersection.d.ts

@@ -0,0 +1,17 @@
+/**
+ * # 两个数组的交集
+ *
+ * @param a 数组 1️⃣
+ * @param b 数组 2️⃣
+ * @returns 返回两个数组的交集
+ * @example
+ * ```ts
+ * import { intersection } from '@mudbean/utils';
+ *
+ * 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

@@ -0,0 +1,38 @@
+import { isArray, isEmptyArray } from '@mudbean/is';
+
+/**
+ * # 两个数组的交集
+ *
+ * @param a 数组 1️⃣
+ * @param b 数组 2️⃣
+ * @returns 返回两个数组的交集
+ * @example
+ * ```ts
+ * import { intersection } from '@mudbean/utils';
+ *
+ * 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)) {
+        throw new TypeError('参数必须是数组类型数据');
+    }
+    // 任意数组为空，则返回空数组
+    if (isEmptyArray(a) || isEmptyArray(b)) {
+        return [];
+    }
+    /**
+     * 在实际运算中， new Set() 的 开销为 O(n) ,filter 的开销也为 O(n)
+     *
+     * 但是以较短的数组创建 Set ，可以节省内存开销
+     */
+    const [shorter, longer] = a.length <= b.length ? [a, b] : [b, a];
+    // 提前创建工具 Set
+    const shortSet = new Set(shorter);
+    return longer.filter(item => shortSet.has(item));
+}
+
+export { intersection };

package/es/array/symmetricDifference.d.ts

@@ -0,0 +1,27 @@
+/**
+ * # 对称差集 （ A △ B）
+ *
+ * @param a  - 数组 a
+ * @param b  - 数组 b
+ * @returns - 返回一个全新的数组
+ * @example
+ * ```ts
+ * import { symmetricDifference } from '@mudbean/utils';
+ *
+ * const log = console.log;
+ *
+ * log(symmetricDifference([1, 2], [2, 3])); // [1, 3]
+ *
+ * log(symmetricDifference([1, 2, 3], [1, 2, 4])); // [3, 4]
+ *
+ * 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

@@ -0,0 +1,43 @@
+import { isArray, isEmptyArray } from '@mudbean/is';
+import { difference } from './difference.js';
+
+/**
+ * # 对称差集 （ A △ B）
+ *
+ * @param a  - 数组 a
+ * @param b  - 数组 b
+ * @returns - 返回一个全新的数组
+ * @example
+ * ```ts
+ * import { symmetricDifference } from '@mudbean/utils';
+ *
+ * const log = console.log;
+ *
+ * log(symmetricDifference([1, 2], [2, 3])); // [1, 3]
+ *
+ * log(symmetricDifference([1, 2, 3], [1, 2, 4])); // [3, 4]
+ *
+ * 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)) {
+        throw new TypeError('参数必须是数组');
+    }
+    if (isEmptyArray(a)) {
+        return [...b];
+    }
+    if (isEmptyArray(b)) {
+        return [...a];
+    }
+    return [...difference(a, b), ...difference(b, a)];
+}
+
+export { symmetricDifference };

package/es/array/union.d.ts

@@ -0,0 +1,39 @@
+/**
+ * # 数组的并集
+ *
+ *  <span style="color:#f36;">请注意，参数有不为数组时直接抛出 TypeError</span>
+ * @param arrays  - 多个数组
+ * @returns 联合后的数组
+ * @example
+ *
+ * ```ts
+ * import { union } from '@mudbean/is';
+ *
+ * const log = console.log;
+ *
+ * // []
+ * log(union());
+ *
+ * // [1, 2, 3]
+ * log(union([1, 2, 3]));
+ *
+ * //  TypeError
+ * log(union([1, 2, 3], 'i'));
+ * log(union([1, 2, 3], undefined));
+ * log(union([1, 2, 3], null));
+ * log(union([1, 2, 3], 4));
+ * log(union([1, 2, 3], {}));
+ * log(union([1, 2, 3], false));
+ *
+ * // [1, 2, 3, 4, 6]
+ * log(union([1, 2, 3], [2, 4, 6]));
+ *
+ * // [1, 2, 3, 4, 6]
+ * log(union([1, 2, 3], [2, 4, 6], [1, 2, 3]));
+ *
+ * // [1, 2, 3, 4, 6]
+ * log(union([1, 2, 3], [2, 4, 6], [1, 2, 3], [1, 2, 3]));
+ * ```
+ *
+ */
+export declare function union<T>(...arrays: T[][]): T[];

package/es/array/union.js

@@ -0,0 +1,60 @@
+import { isEmptyArray, isArray } from '@mudbean/is';
+
+/**
+ * # 数组的并集
+ *
+ *  <span style="color:#f36;">请注意，参数有不为数组时直接抛出 TypeError</span>
+ * @param arrays  - 多个数组
+ * @returns 联合后的数组
+ * @example
+ *
+ * ```ts
+ * import { union } from '@mudbean/is';
+ *
+ * const log = console.log;
+ *
+ * // []
+ * log(union());
+ *
+ * // [1, 2, 3]
+ * log(union([1, 2, 3]));
+ *
+ * //  TypeError
+ * log(union([1, 2, 3], 'i'));
+ * log(union([1, 2, 3], undefined));
+ * log(union([1, 2, 3], null));
+ * log(union([1, 2, 3], 4));
+ * log(union([1, 2, 3], {}));
+ * log(union([1, 2, 3], false));
+ *
+ * // [1, 2, 3, 4, 6]
+ * log(union([1, 2, 3], [2, 4, 6]));
+ *
+ * // [1, 2, 3, 4, 6]
+ * log(union([1, 2, 3], [2, 4, 6], [1, 2, 3]));
+ *
+ * // [1, 2, 3, 4, 6]
+ * log(union([1, 2, 3], [2, 4, 6], [1, 2, 3], [1, 2, 3]));
+ * ```
+ *
+ */
+function union(...arrays) {
+    if (isEmptyArray(arrays)) {
+        return [];
+    }
+    if (arrays.some(i => !isArray(i))) {
+        throw new TypeError('参数必须都是数组形式的元素');
+    }
+    if (arrays.length === 1) {
+        return [...arrays[0]];
+    }
+    const resultSet = new Set();
+    for (const array of arrays) {
+        for (const item of array) {
+            resultSet.add(item);
+        }
+    }
+    return Array.from(resultSet);
+}
+
+export { union };

package/es/className.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 驼峰命名与连字符命名法的互换
+ */
+/**
+ * # 连字符连接转化为小/大驼峰命名法
+ *
+ * @param str    待转化文本
+ * @param dividingType   连字符，缺省值为 "-"
+ * @param initial 是否转换第一个字符。默认值为 false （小驼峰类型）
+ * @returns 驼峰命名法字符串（e.g. “helloWorld”）
+ */
+export declare function toLowerCamelCase(
+/**  待转化文本  */
+str: string, 
+/**  连字符，缺省值为 "-"  */
+dividingType?: string, 
+/** 是否转换第一个字符。默认值为 false （小驼峰类型） */
+initial?: boolean): string;
+/**
+ * # 驼峰命名法转化为连字符连接
+ *
+ * @param str          待转化文本
+ * @param dividingType       分割符
+ * @returns 分割符转化的文本 (e.g. 'hello-world')
+ */
+export declare function toSplitCase(str: string, dividingType?: string): string;