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

package/src/array/union.mjs.js

@@ -1,59 +0,0 @@
-import { isEmptyArray, isArray } from '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 (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/src/className.cjs.js

@@ -1,58 +0,0 @@
-'use strict';
-
-/**
- * 驼峰命名与连字符命名法的互换
- *
- * @packageDocumentation
- * @module @a-js-tools/class-name
- * @license MIT
- */
-/**
- *
- * 连字符连接转化为小/大驼峰命名法
- *
- * @param str    待转化文本
- * @param dividingType   连字符，缺省值为 "-"
- * @param initial 是否转换第一个字符。默认值为 false （小驼峰类型）
- * @returns 驼峰命名法字符串（e.g. “helloWorld”）
- *
- */
-function toLowerCamelCase(
-/**  待转化文本  */
-str, 
-/**  连字符，缺省值为 "-"  */
-dividingType = '-', 
-/** 是否转换第一个字符。默认值为 false （小驼峰类型） */
-initial = false) {
-    let result = str;
-    /**
-     * 匹配规则
-     *
-     * - 匹配到分隔符，将分隔符后面的字符转化为大写
-     */
-    const template = /[\\]|[\^]|[?]|[-]|[.]|[(]|[)]|[|]|[[]\[\]]|[{]|[}]|[+]|[*]|[$]/;
-    /**  转化首字符   */
-    const toTransform = (_str, _dividingType) => _str.replace(new RegExp(`${template.test(_dividingType) ? `\\${_dividingType}` : _dividingType}([a-zA-Z])`, 'g'), (match, p1) => p1.toUpperCase());
-    // 多分隔符转化
-    dividingType
-        .split('')
-        .forEach((item) => (result = toTransform(result, item)));
-    return initial
-        ? result.replace(/^./, (match) => match.toUpperCase())
-        : result;
-}
-/**
- * 驼峰命名法转化为连字符连接
- *
- * @param str          待转化文本
- * @param dividingType       分割符
- * @returns 分割符转化的文本 (e.g. 'hello-world')
- *
- */
-function toSplitCase(str, dividingType = '-') {
-    const result = str.replace(/[A-Z]/g, (match) => dividingType.concat(match.toLowerCase()));
-    return result.startsWith(dividingType) ? result.substring(1) : result;
-}
-
-exports.toLowerCamelCase = toLowerCamelCase;
-exports.toSplitCase = toSplitCase;

package/src/className.mjs.js

@@ -1,55 +0,0 @@
-/**
- * 驼峰命名与连字符命名法的互换
- *
- * @packageDocumentation
- * @module @a-js-tools/class-name
- * @license MIT
- */
-/**
- *
- * 连字符连接转化为小/大驼峰命名法
- *
- * @param str    待转化文本
- * @param dividingType   连字符，缺省值为 "-"
- * @param initial 是否转换第一个字符。默认值为 false （小驼峰类型）
- * @returns 驼峰命名法字符串（e.g. “helloWorld”）
- *
- */
-function toLowerCamelCase(
-/**  待转化文本  */
-str, 
-/**  连字符，缺省值为 "-"  */
-dividingType = '-', 
-/** 是否转换第一个字符。默认值为 false （小驼峰类型） */
-initial = false) {
-    let result = str;
-    /**
-     * 匹配规则
-     *
-     * - 匹配到分隔符，将分隔符后面的字符转化为大写
-     */
-    const template = /[\\]|[\^]|[?]|[-]|[.]|[(]|[)]|[|]|[[]\[\]]|[{]|[}]|[+]|[*]|[$]/;
-    /**  转化首字符   */
-    const toTransform = (_str, _dividingType) => _str.replace(new RegExp(`${template.test(_dividingType) ? `\\${_dividingType}` : _dividingType}([a-zA-Z])`, 'g'), (match, p1) => p1.toUpperCase());
-    // 多分隔符转化
-    dividingType
-        .split('')
-        .forEach((item) => (result = toTransform(result, item)));
-    return initial
-        ? result.replace(/^./, (match) => match.toUpperCase())
-        : result;
-}
-/**
- * 驼峰命名法转化为连字符连接
- *
- * @param str          待转化文本
- * @param dividingType       分割符
- * @returns 分割符转化的文本 (e.g. 'hello-world')
- *
- */
-function toSplitCase(str, dividingType = '-') {
-    const result = str.replace(/[A-Z]/g, (match) => dividingType.concat(match.toLowerCase()));
-    return result.startsWith(dividingType) ? result.substring(1) : result;
-}
-
-export { toLowerCamelCase, toSplitCase };

package/src/getRandomNumber.cjs.js

@@ -1,76 +0,0 @@
-'use strict';
-
-var aTypeOfJs = require('a-type-of-js');
-
-/**
- * 过去随机数
- *
- * @packageDocumentation
- * @module @a-js-tools/get-random-number
- * @license MIT
- */
-/**
- *
- * 获取一个随机的整数类型
- *
- * 您可以传入两个参数并获取它们之间的任意数字，返回值<span style="color:#ff0;">*会包含端值*</span>
- *
- * 如果只传递一个参数，则如果提供的值为负数，则得到一个小于（或大于）该数字的整数
- *
- * @param   max 较大值 ，不允许为`NaN`
- * @param   min 较小值，不允许为 `NaN`
- * @returns  任意的整数
- */
-function getRandomInt(max = 1, min = 0) {
-    //  判断是否为 NaN 或 不是数字
-    if (!isFinite(max) ||
-        !isFinite(min) ||
-        aTypeOfJs.isNaN(max) ||
-        aTypeOfJs.isNaN(min) ||
-        !aTypeOfJs.isNumber(max) ||
-        !aTypeOfJs.isNumber(min)) {
-        throw new TypeError('getRandomInt: max or min is NaN or is not a number');
-    }
-    /**  获取最小值  */
-    let _min = Math.ceil(Number(min)), 
-    /**  获取最大值  */
-    _max = Math.floor(Number(max));
-    //  两值相等时，直接返回最大值
-    if (_max === _min)
-        return _max;
-    //  两值交换
-    if (_min > _max)
-        [_max, _min] = [_min, _max];
-    return Math.round(Math.random() * (_max - _min) + _min);
-}
-/**
- *
- * 获取任意的浮点数
- *
- * 您可以传入两个参数并获取它们之间的任意数字
- *
- * 如果只传入一个参数，则如果提供的值为负数，则获取小于（或大于）该数字的浮点数
- *
- * @param   max 较大数，缺省值为 1
- * @param min 较小值，缺省值为 0
- * @returns  任意的浮点数
- */
-function getRandomFloat(max = 1, min = 0) {
-    //  判断是否为 NaN 或 不是数字
-    if (!isFinite(max) ||
-        !isFinite(min) ||
-        aTypeOfJs.isNaN(max) ||
-        aTypeOfJs.isNaN(min) ||
-        !aTypeOfJs.isNumber(max) ||
-        !aTypeOfJs.isNumber(min)) {
-        throw new TypeError('getRandomInt: max or min is NaN or is not a number');
-    }
-    if (max == min)
-        max++;
-    if (min > max)
-        [max, min] = [min, max];
-    return Math.random() * (max - min) + min;
-}
-
-exports.getRandomFloat = getRandomFloat;
-exports.getRandomInt = getRandomInt;

package/src/getRandomNumber.mjs.js

@@ -1,73 +0,0 @@
-import { isNaN, isNumber } from 'a-type-of-js';
-
-/**
- * 过去随机数
- *
- * @packageDocumentation
- * @module @a-js-tools/get-random-number
- * @license MIT
- */
-/**
- *
- * 获取一个随机的整数类型
- *
- * 您可以传入两个参数并获取它们之间的任意数字，返回值<span style="color:#ff0;">*会包含端值*</span>
- *
- * 如果只传递一个参数，则如果提供的值为负数，则得到一个小于（或大于）该数字的整数
- *
- * @param   max 较大值 ，不允许为`NaN`
- * @param   min 较小值，不允许为 `NaN`
- * @returns  任意的整数
- */
-function getRandomInt(max = 1, min = 0) {
-    //  判断是否为 NaN 或 不是数字
-    if (!isFinite(max) ||
-        !isFinite(min) ||
-        isNaN(max) ||
-        isNaN(min) ||
-        !isNumber(max) ||
-        !isNumber(min)) {
-        throw new TypeError('getRandomInt: max or min is NaN or is not a number');
-    }
-    /**  获取最小值  */
-    let _min = Math.ceil(Number(min)), 
-    /**  获取最大值  */
-    _max = Math.floor(Number(max));
-    //  两值相等时，直接返回最大值
-    if (_max === _min)
-        return _max;
-    //  两值交换
-    if (_min > _max)
-        [_max, _min] = [_min, _max];
-    return Math.round(Math.random() * (_max - _min) + _min);
-}
-/**
- *
- * 获取任意的浮点数
- *
- * 您可以传入两个参数并获取它们之间的任意数字
- *
- * 如果只传入一个参数，则如果提供的值为负数，则获取小于（或大于）该数字的浮点数
- *
- * @param   max 较大数，缺省值为 1
- * @param min 较小值，缺省值为 0
- * @returns  任意的浮点数
- */
-function getRandomFloat(max = 1, min = 0) {
-    //  判断是否为 NaN 或 不是数字
-    if (!isFinite(max) ||
-        !isFinite(min) ||
-        isNaN(max) ||
-        isNaN(min) ||
-        !isNumber(max) ||
-        !isNumber(min)) {
-        throw new TypeError('getRandomInt: max or min is NaN or is not a number');
-    }
-    if (max == min)
-        max++;
-    if (min > max)
-        [max, min] = [min, max];
-    return Math.random() * (max - min) + min;
-}
-
-export { getRandomFloat, getRandomInt };

package/src/getRandomString.cjs.js

@@ -1,107 +0,0 @@
-'use strict';
-
-var aTypeOfJs = require('a-type-of-js');
-
-/**
- * 获取随机字符串
- *
- * @packageDocumentation
- * @module @a-js-tools/get-random-string
- * @license MIT
- */
-/**
- *
- *  获取简单的随机字符串
- *
- *  @param   options - 字符串长度
- *  @returns  - 随机字符串
- *
- *
- */
-function getRandomString(options) {
-    //   验证输入参数
-    if (
-    // 参数类型错误
-    (!aTypeOfJs.isPlainObject(options) && !aTypeOfJs.isNumber(options)) ||
-        // 参数为 NaN
-        (aTypeOfJs.isNumber(options) && aTypeOfJs.isNaN(options)) ||
-        // 参数为数字时为无穷大
-        (aTypeOfJs.isNumber(options) && !isFinite(options)) ||
-        // 参数为数字时为非整数
-        (aTypeOfJs.isNumber(options) && !Number.isInteger(options)) ||
-        // 参数为数字时为负数
-        (aTypeOfJs.isNumber(options) && Number.isInteger(options) && options < 1) ||
-        // 参数为数值然而却小于 1
-        (aTypeOfJs.isNumber(options) && options < 1) ||
-        // 参数为对象但是 length 属性非数值
-        (aTypeOfJs.isPlainObject(options) &&
-            (!aTypeOfJs.isNumber(options.length) ||
-                options.length < 1 ||
-                !Number.isInteger(options.length))))
-        throw new TypeError('参数类型错误 ❌ (getRandomString)');
-    const initOptions = {
-        length: 32,
-        chars: 'abcdefghijklmnopqrstuvwxyz',
-        chars2: '0123456789',
-        chars3: '!@#$%^&*()_+~`|}{[]:;?><,./-=',
-        type: 'string',
-        includeUppercaseLetters: false,
-        includeNumbers: false,
-        includeSpecial: false,
-    };
-    /// 生成 UUID
-    if (initOptions.type === 'uuid')
-        return crypto.randomUUID();
-    // 验证输入参数
-    if (aTypeOfJs.isNumber(options) && Number.isInteger(options) && options > 0)
-        Object.assign(initOptions, { length: options });
-    if (aTypeOfJs.isPlainObject(options)) {
-        Object.assign(initOptions, options);
-        initOptions.length = initOptions.length < 1 ? 32 : initOptions.length;
-    }
-    /**  生成随机字符串  */
-    const templateCharsArr = initOptions.chars.split('');
-    // 添加大写字母
-    if (initOptions.includeUppercaseLetters)
-        interleaveString(templateCharsArr, initOptions.chars.toUpperCase());
-    // 添加数字
-    if (initOptions.includeNumbers)
-        interleaveString(templateCharsArr, initOptions.chars2);
-    // 添加特殊字符
-    if (initOptions.includeSpecial)
-        interleaveString(templateCharsArr, initOptions.chars3);
-    // 使用密码学安全的随机数生成器
-    const bytes = globalThis.crypto.getRandomValues(new Uint8Array(initOptions.length));
-    let result = '';
-    /**  获取最后的 chars 数据  */
-    const chars = templateCharsArr.join('');
-    // 循环遍历
-    bytes.forEach(byte => (result += chars.charAt(byte % chars.length)));
-    /**
-     *
-     *  字符串交叉函数
-     *
-     *  非线形串交叉，对相交叉
-     *
-     *  @param  str1 - 字符串1
-     *  @param  str2 - 字符串2
-     *  @returns - 交叉后的字符串
-     *  @example
-     *  ```ts
-     *  interleaveString('abc', '123') // 'a1b2c3'
-     *  ```
-     */
-    function interleaveString(str1, str2) {
-        const str1Length = str1.length, str2Length = str2.length;
-        const maxLength = Math.max(str1Length, str2Length);
-        for (let i = 0; i < maxLength; i++) {
-            if (i < str1Length && !aTypeOfJs.isUndefined(str2[i]))
-                str1[i] += str2[i];
-            else if (i < str2Length)
-                str1[i] = str2[i];
-        }
-    }
-    return result;
-}
-
-exports.getRandomString = getRandomString;

package/src/getRandomString.mjs.js

@@ -1,105 +0,0 @@
-import { isPlainObject, isNumber, isNaN, isUndefined } from 'a-type-of-js';
-
-/**
- * 获取随机字符串
- *
- * @packageDocumentation
- * @module @a-js-tools/get-random-string
- * @license MIT
- */
-/**
- *
- *  获取简单的随机字符串
- *
- *  @param   options - 字符串长度
- *  @returns  - 随机字符串
- *
- *
- */
-function getRandomString(options) {
-    //   验证输入参数
-    if (
-    // 参数类型错误
-    (!isPlainObject(options) && !isNumber(options)) ||
-        // 参数为 NaN
-        (isNumber(options) && isNaN(options)) ||
-        // 参数为数字时为无穷大
-        (isNumber(options) && !isFinite(options)) ||
-        // 参数为数字时为非整数
-        (isNumber(options) && !Number.isInteger(options)) ||
-        // 参数为数字时为负数
-        (isNumber(options) && Number.isInteger(options) && options < 1) ||
-        // 参数为数值然而却小于 1
-        (isNumber(options) && options < 1) ||
-        // 参数为对象但是 length 属性非数值
-        (isPlainObject(options) &&
-            (!isNumber(options.length) ||
-                options.length < 1 ||
-                !Number.isInteger(options.length))))
-        throw new TypeError('参数类型错误 ❌ (getRandomString)');
-    const initOptions = {
-        length: 32,
-        chars: 'abcdefghijklmnopqrstuvwxyz',
-        chars2: '0123456789',
-        chars3: '!@#$%^&*()_+~`|}{[]:;?><,./-=',
-        type: 'string',
-        includeUppercaseLetters: false,
-        includeNumbers: false,
-        includeSpecial: false,
-    };
-    /// 生成 UUID
-    if (initOptions.type === 'uuid')
-        return crypto.randomUUID();
-    // 验证输入参数
-    if (isNumber(options) && Number.isInteger(options) && options > 0)
-        Object.assign(initOptions, { length: options });
-    if (isPlainObject(options)) {
-        Object.assign(initOptions, options);
-        initOptions.length = initOptions.length < 1 ? 32 : initOptions.length;
-    }
-    /**  生成随机字符串  */
-    const templateCharsArr = initOptions.chars.split('');
-    // 添加大写字母
-    if (initOptions.includeUppercaseLetters)
-        interleaveString(templateCharsArr, initOptions.chars.toUpperCase());
-    // 添加数字
-    if (initOptions.includeNumbers)
-        interleaveString(templateCharsArr, initOptions.chars2);
-    // 添加特殊字符
-    if (initOptions.includeSpecial)
-        interleaveString(templateCharsArr, initOptions.chars3);
-    // 使用密码学安全的随机数生成器
-    const bytes = globalThis.crypto.getRandomValues(new Uint8Array(initOptions.length));
-    let result = '';
-    /**  获取最后的 chars 数据  */
-    const chars = templateCharsArr.join('');
-    // 循环遍历
-    bytes.forEach(byte => (result += chars.charAt(byte % chars.length)));
-    /**
-     *
-     *  字符串交叉函数
-     *
-     *  非线形串交叉，对相交叉
-     *
-     *  @param  str1 - 字符串1
-     *  @param  str2 - 字符串2
-     *  @returns - 交叉后的字符串
-     *  @example
-     *  ```ts
-     *  interleaveString('abc', '123') // 'a1b2c3'
-     *  ```
-     */
-    function interleaveString(str1, str2) {
-        const str1Length = str1.length, str2Length = str2.length;
-        const maxLength = Math.max(str1Length, str2Length);
-        for (let i = 0; i < maxLength; i++) {
-            if (i < str1Length && !isUndefined(str2[i]))
-                str1[i] += str2[i];
-            else if (i < str2Length)
-                str1[i] = str2[i];
-        }
-    }
-    return result;
-}
-
-export { getRandomString };

package/src/isNode.cjs.js

@@ -1,23 +0,0 @@
-'use strict';
-
-var aTypeOfJs = require('a-type-of-js');
-
-/**
- *
- * 判断当前环境是否为 node 环境
- *
- */
-function isNode() {
-    return !aTypeOfJs.isUndefined(globalThis?.process?.versions?.node);
-}
-/**
- *
- * 是否为浏览器环境
- *
- */
-function isBrowser() {
-    return !isNode();
-}
-
-exports.isBrowser = isBrowser;
-exports.isNode = isNode;

package/src/isNode.mjs.js

@@ -1,20 +0,0 @@
-import { isUndefined } from 'a-type-of-js';
-
-/**
- *
- * 判断当前环境是否为 node 环境
- *
- */
-function isNode() {
-    return !isUndefined(globalThis?.process?.versions?.node);
-}
-/**
- *
- * 是否为浏览器环境
- *
- */
-function isBrowser() {
-    return !isNode();
-}
-
-export { isBrowser, isNode };

package/src/object/createConstructor.cjs.js

@@ -1,51 +0,0 @@
-'use strict';
-
-/**
- *
- * 构建一个 Constructor 构造函数
- *
- * 接收一个构造函数，然后返回 TS 能识别的构造函数自身
- *
- * 函数本身并没有执行任何逻辑，仅是简单的返回了实参自身
- *
- * 而经过该函数的包装，构造函数成了能够被 TS 识别为可用 new 实例的构造函数
- *
- * @param constructor - 传入一个构造函数
- * @returns 返回传入的构造函数
- *
- * ```ts
- * import { createConstructor } from "a-js-tools";
- *
- * type Tom = {
- *   a: number
- * }
- *
- * function _Tom (this: TomType): Tom {
- *    this.a = 1;
- *
- *    return this;
- * }
- *
- * // 逻辑上没有错，但是会造成 ts 显示
- * // 其目标缺少构造签名的 "new" 表达式隐式具有 "any" 类型。ts(7009)
- * const a = new _Tom();
- *
- * const tomConstructor = createConstructor(_tom);
- *
- * const b = new tomConstructor(); // 这时就不会显示错误
- *
- * ```
- *
- */
-function createConstructor(constructor) {
-    constructor.prototype.apply = Function.apply;
-    constructor.prototype.bind = Function.bind;
-    constructor.prototype.call = Function.call;
-    constructor.prototype.length = Function.length;
-    // constructor.prototype.arguments = Function.arguments;
-    constructor.prototype.name = Function.name;
-    constructor.prototype.toString = Function.toString;
-    return constructor;
-}
-
-exports.createConstructor = createConstructor;

package/src/object/createConstructor.mjs.js

@@ -1,49 +0,0 @@
-/**
- *
- * 构建一个 Constructor 构造函数
- *
- * 接收一个构造函数，然后返回 TS 能识别的构造函数自身
- *
- * 函数本身并没有执行任何逻辑，仅是简单的返回了实参自身
- *
- * 而经过该函数的包装，构造函数成了能够被 TS 识别为可用 new 实例的构造函数
- *
- * @param constructor - 传入一个构造函数
- * @returns 返回传入的构造函数
- *
- * ```ts
- * import { createConstructor } from "a-js-tools";
- *
- * type Tom = {
- *   a: number
- * }
- *
- * function _Tom (this: TomType): Tom {
- *    this.a = 1;
- *
- *    return this;
- * }
- *
- * // 逻辑上没有错，但是会造成 ts 显示
- * // 其目标缺少构造签名的 "new" 表达式隐式具有 "any" 类型。ts(7009)
- * const a = new _Tom();
- *
- * const tomConstructor = createConstructor(_tom);
- *
- * const b = new tomConstructor(); // 这时就不会显示错误
- *
- * ```
- *
- */
-function createConstructor(constructor) {
-    constructor.prototype.apply = Function.apply;
-    constructor.prototype.bind = Function.bind;
-    constructor.prototype.call = Function.call;
-    constructor.prototype.length = Function.length;
-    // constructor.prototype.arguments = Function.arguments;
-    constructor.prototype.name = Function.name;
-    constructor.prototype.toString = Function.toString;
-    return constructor;
-}
-
-export { createConstructor };