a-js-tools 1.0.13-beta.0 → 1.0.13-beta.2

package/index.d.ts

@@ -1,10 +1,9 @@
-import { CreateConstructor, createConstructor } from './src/object/createConstructor';
+export type { CreateConstructor } from './src/object/createConstructor';
+export { createConstructor, ObjectAssign, } from './src/object/createConstructor';
 export { toLowerCamelCase, toSplitCase, getRandomFloat, getRandomInt, getRandomString, } from './src/index';
 export { throttle, debounce } from './src/performance';
 export type { DebounceAndThrottleReturnType } from './src/performance';
 export { escapeRegExp, autoEscapedRegExp } from './src/regexp';
 export { isBrowser, isNode } from './src/isNode';
 export { intersection, enArr, union, difference, symmetricDifference, } from './src/array/';
-export { createConstructor };
-export type { CreateConstructor };
 export { sleep } from './src/sleep';

package/package.json

@@ -1,6 +1,6 @@
 {
   "type": "module",
-  "version": "1.0.13-beta.0",
+  "version": "1.0.13-beta.2",
   "name": "a-js-tools",
   "description": "一点点 🤏  js 函数",
   "license": "MIT",

package/src/object/createConstructor.d.ts

@@ -45,3 +45,5 @@ export interface CreateConstructor<T, Args extends unknown[] = unknown[]> {
  *
  */
 export declare function createConstructor<T, Args extends unknown[] = unknown[]>(constructor: (...argumentList: Args) => T): CreateConstructor<T, Args>;
+/** 对象的 assign 用法 */
+export declare function ObjectAssign(target: Record<string, unknown>, bar: Record<string, unknown>): Record<string, unknown>;

package/src/array/difference.cjs.js

@@ -1,49 +0,0 @@
-'use strict';
-
-var aTypeOfJs = require('a-type-of-js');
-
-/**
- *  求给出的两个数组的差值（A - B）
- *
- * @param a  - 第一个数组
- * @param b - 第二个数组
- * @throws {TypeError} 当两个参数有一个不是
- * @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]
- *
- * 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 (!aTypeOfJs.isArray(a) || !aTypeOfJs.isArray(b))
-        throw new TypeError('参数需为数组');
-    if (aTypeOfJs.isEmptyArray(a) || aTypeOfJs.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));
-}
-
-exports.difference = difference;

package/src/array/difference.mjs.js

@@ -1,47 +0,0 @@
-import { isArray, isEmptyArray } from 'a-type-of-js';
-
-/**
- *  求给出的两个数组的差值（A - B）
- *
- * @param a  - 第一个数组
- * @param b - 第二个数组
- * @throws {TypeError} 当两个参数有一个不是
- * @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]
- *
- * 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/src/array/index.cjs.js

@@ -1,154 +0,0 @@
-'use strict';
-
-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）
- *
- */
-const enArr = {
-    /**
-     *
-     * 数组的并集
-     *
-     *  <span style="color:#f36;">请注意，参数有不为数组时直接抛出 TypeError</span>
-     * @param arrays  - 多个数组
-     * @returns 联合后的数组
-     *
-     *
-     * @example
-     *
-     * ```ts
-     * import { union } from 'a-js-tools';
-     *
-     * 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: 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）
-     *
-     * @param a  - 第一个数组
-     * @param b - 第二个数组
-     * @throws {TypeError} 当两个参数有一个不是
-     * @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]
-     *
-     * 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: difference.difference,
-    /**
-     *
-     * 对称差集 （ A △ B）
-     *
-     * @param a  - 数组 a
-     * @param b  - 数组 b
-     * @returns - 返回一个全新的数组
-     *
-     * @example
-     *
-     * ```ts
-     * import { symmetricDifference } from 'a-js-tools';
-     *
-     * 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: symmetricDifference.symmetricDifference,
-};
-
-exports.intersection = intersection.intersection;
-exports.union = union.union;
-exports.difference = difference.difference;
-exports.symmetricDifference = symmetricDifference.symmetricDifference;
-exports.enArr = enArr;

package/src/array/index.mjs.js

@@ -1,148 +0,0 @@
-import { intersection } from './intersection.mjs.js';
-import { union } from './union.mjs.js';
-import { difference } from './difference.mjs.js';
-import { symmetricDifference } from './symmetricDifference.mjs.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 'a-js-tools';
-     *
-     * 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 '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）
-     *
-     * @param a  - 第一个数组
-     * @param b - 第二个数组
-     * @throws {TypeError} 当两个参数有一个不是
-     * @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]
-     *
-     * 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 'a-js-tools';
-     *
-     * 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/src/array/intersection.cjs.js

@@ -1,43 +0,0 @@
-'use strict';
-
-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))
-        throw new TypeError('参数必须是数组类型数据');
-    // 任意数组为空，则返回空数组
-    if (aTypeOfJs.isEmptyArray(a) || aTypeOfJs.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));
-}
-
-exports.intersection = intersection;

package/src/array/intersection.mjs.js

@@ -1,41 +0,0 @@
-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))
-        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/src/array/symmetricDifference.cjs.js

@@ -1,48 +0,0 @@
-'use strict';
-
-var aTypeOfJs = require('a-type-of-js');
-var difference = require('./difference.cjs.js');
-
-/**
- *
- * 对称差集 （ A △ B）
- *
- * @param a  - 数组 a
- * @param b  - 数组 b
- * @returns - 返回一个全新的数组
- *
- * @example
- *
- * ```ts
- * import { symmetricDifference } from 'a-js-tools';
- *
- * 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 (!aTypeOfJs.isArray(a) || !aTypeOfJs.isArray(b))
-        throw new TypeError('参数必须是数组');
-    if (aTypeOfJs.isEmptyArray(a))
-        return [...b];
-    if (aTypeOfJs.isEmptyArray(b))
-        return [...a];
-    return [...difference.difference(a, b), ...difference.difference(b, a)];
-}
-
-exports.symmetricDifference = symmetricDifference;

package/src/array/symmetricDifference.mjs.js

@@ -1,46 +0,0 @@
-import { isArray, isEmptyArray } from 'a-type-of-js';
-import { difference } from './difference.mjs.js';
-
-/**
- *
- * 对称差集 （ A △ B）
- *
- * @param a  - 数组 a
- * @param b  - 数组 b
- * @returns - 返回一个全新的数组
- *
- * @example
- *
- * ```ts
- * import { symmetricDifference } from 'a-js-tools';
- *
- * 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/src/array/union.cjs.js

@@ -1,61 +0,0 @@
-'use strict';
-
-var aTypeOfJs = require('a-type-of-js');
-
-/**
- *
- * 数组的并集
- *
- *  <span style="color:#f36;">请注意，参数有不为数组时直接抛出 TypeError</span>
- * @param arrays  - 多个数组
- * @returns 联合后的数组
- *
- *
- * @example
- *
- * ```ts
- * import { union } from 'a-js-tools';
- *
- * 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 (aTypeOfJs.isEmptyArray(arrays))
-        return [];
-    if (arrays.some(i => !aTypeOfJs.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);
-}
-
-exports.union = union;