a-js-tools 0.2.0 → 0.3.0

package/README.md

@@ -9,13 +9,15 @@
 npm install   a-js-tools  --save
 ```
 
-## pure function
+## 纯函数
 
 - `lmDebounce` 防抖函数
 - `lmThrottle` 节流函数
 - `getRandomInt` 获取随机的整数
 - `getRandomFloat` 获取随机的浮点数
 - `getRandomString` 获取随机字符串
+- `escapeRegExp` 转义字符串为简单的正则表达式
+- `autoEscapedRegExp` 生成简单的正则表达式
 
 ## class 名称转化
 

package/cjs/index.cjs

@@ -4,6 +4,8 @@ var getRandomNumber = require('./src/getRandomNumber.cjs');
 var className = require('./src/className.cjs');
 var getRandomString = require('./src/getRandomString.cjs');
 var performance = require('./src/performance.cjs');
+var escapeRegExp = require('./src/regexp/escapeRegExp.cjs');
+var autoEscapedRegExp = require('./src/regexp/autoEscapedRegExp.cjs');
 
 
 
@@ -14,3 +16,5 @@ exports.toSplitCase = className.toSplitCase;
 exports.getRandomString = getRandomString.getRandomString;
 exports.debounce = performance.debounce;
 exports.throttle = performance.throttle;
+exports.escapeRegExp = escapeRegExp.escapeRegExp;
+exports.autoEscapedRegExp = autoEscapedRegExp.autoEscapedRegExp;

package/cjs/src/getRandomString.cjs

@@ -1,7 +1,6 @@
 'use strict';
 
 var aTypeOfJs = require('a-type-of-js');
-var crypto$1 = require('crypto');
 
 /**
  * 获取随机字符串
@@ -12,30 +11,34 @@ var crypto$1 = require('crypto');
  */
 /**
  *
- *  获取随机字符串
+ *  获取简单的随机字符串
  *
- *  @param   length - 字符串长度
+ *  @param   options - 字符串长度
  *  @returns  - 随机字符串
  *
  *
  */
-function getRandomString(length) {
+function getRandomString(options) {
     //   验证输入参数
     if (
     // 参数类型错误
-    (!aTypeOfJs.isPlainObject(length) && !aTypeOfJs.isNumber(length)) ||
+    (!aTypeOfJs.isPlainObject(options) && !aTypeOfJs.isNumber(options)) ||
         // 参数为 NaN
-        (aTypeOfJs.isNumber(length) && aTypeOfJs.isNaN(length)) ||
+        (aTypeOfJs.isNumber(options) && aTypeOfJs.isNaN(options)) ||
         // 参数为数字时为无穷大
-        (aTypeOfJs.isNumber(length) && !isFinite(length)) ||
+        (aTypeOfJs.isNumber(options) && !isFinite(options)) ||
         // 参数为数字时为非整数
-        (aTypeOfJs.isNumber(length) && !Number.isInteger(length)) ||
+        (aTypeOfJs.isNumber(options) && !Number.isInteger(options)) ||
         // 参数为数字时为负数
-        (aTypeOfJs.isNumber(length) && Number.isInteger(length) && length < 1) ||
+        (aTypeOfJs.isNumber(options) && Number.isInteger(options) && options < 1) ||
         // 参数为数值然而却小于 1
-        (aTypeOfJs.isNumber(length) && length < 1) ||
-        (aTypeOfJs.isPlainObject(length) && aTypeOfJs.isNumber(length.length) && length.length < 1)) {
-        throw new TypeError('Invalid argument type (getRandomString)');
+        (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,
@@ -51,12 +54,12 @@ function getRandomString(length) {
     if (initOptions.type === 'uuid') {
         return crypto.randomUUID();
     }
-    if (aTypeOfJs.isNumber(length) && Number.isInteger(length) && length > 0) {
+    if (aTypeOfJs.isNumber(options) && Number.isInteger(options) && options > 0) {
         // 验证输入参数
-        Object.assign(initOptions, { length });
+        Object.assign(initOptions, { length: options });
     }
-    if (aTypeOfJs.isPlainObject(length)) {
-        Object.assign(initOptions, length);
+    if (aTypeOfJs.isPlainObject(options)) {
+        Object.assign(initOptions, options);
         initOptions.length = initOptions.length < 1 ? 32 : initOptions.length;
     }
     /**  生成随机字符串  */
@@ -74,7 +77,9 @@ function getRandomString(length) {
         interleaveString(templateCharsArr, initOptions.chars3);
     }
     // 使用密码学安全的随机数生成器
-    const bytes = crypto$1.randomBytes(initOptions.length);
+    const bytes = !aTypeOfJs.isUndefined(window) && window.crypto
+        ? window.crypto.getRandomValues(new Uint8Array(initOptions.length))
+        : global.crypto.getRandomValues(new Uint8Array(initOptions.length));
     let result = '';
     /**  获取最后的 chars 数据  */
     const chars = templateCharsArr.join('');

package/cjs/src/performance.cjs

@@ -65,7 +65,7 @@ function debounce(callback, delay = 200) {
  */
 function throttle(callback, delay = 200) {
     // 强制转换非数值
-    if (!isFinite(delay) || (isFinite(delay) && delay < 0))
+    if (!isFinite(delay) || (isFinite(delay) && delay < 4))
         delay = 200;
     /**  延迟控制插销   */
     let inThrottle = false;

package/cjs/src/regexp/autoEscapedRegExp.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+var aTypeOfJs = require('a-type-of-js');
+var escapeRegExp = require('./escapeRegExp.cjs');
+var parse = require('./parse.cjs');
+
+/**
+ *
+ * ##  适用于简单的文本字符串自动转化为简单模式正则表达式
+ *
+ * *若字符串包含且需保留字符类、组、反向引用、量词等时，该方法可能不适用*
+ *
+ * @param pattern 待转化的文本字符串
+ * @param options 转化选项。 为文本字符串时，默认为正则表达式的标志，还可指定是否匹配开头或结尾
+ * @returns 正则表达式
+ * @example
+ *
+ * ```ts
+ * import { autoEscapedRegExp } from 'a-regexp';
+ *
+ * autoEscapedRegExp('abc'); // => /abc/
+ * autoEscapedRegExp('abc', 'gim'); // => /abc/gim
+ * autoEscapedRegExp('abc',  { flags: 'g', start: true }); // => /^abc/g
+ * autoEscapedRegExp('abc',  { flags: 'g', end: true }); // => /abc$/g
+ * autoEscapedRegExp('abc',  { start: true, end: true }); // => /^abc$/
+ *
+ * // 转化特殊字符类、组、反向引用、量词等
+ * // 无法保留匹配规则
+ * autoEscapedRegExp('a-zA-Z0-9'); // => /a-zA-Z0-9/
+ * 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 (!aTypeOfJs.isString(pattern)) {
+        throw new TypeError('pattern must be a 字符串');
+    }
+    pattern = escapeRegExp.escapeRegExp(pattern);
+    /** 简单转化  */
+    if (aTypeOfJs.isUndefined(options)) {
+        return new RegExp(pattern);
+    }
+    options = parse.parse(options);
+    return new RegExp(`${options.start ? '^' : ''}${pattern}${options.end ? '$' : ''}`, options.flags);
+}
+
+exports.autoEscapedRegExp = autoEscapedRegExp;

package/cjs/src/regexp/escapeRegExp.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+/**
+ *
+ * 将一个字符串转化为符合正则要求的字符串
+ *
+ * @param str 需要转义的字符串
+ * @requires escapeRegExp 转化后字符串
+ * @example
+ *
+ * ```ts
+ *  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\\$'
+ * ```
+ */
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+exports.escapeRegExp = escapeRegExp;

package/cjs/src/regexp/parse.cjs

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

package/mjs/index.mjs

@@ -2,3 +2,5 @@ export { getRandomFloat, getRandomInt } from './src/getRandomNumber.mjs';
 export { toLowerCamelCase, toSplitCase } from './src/className.mjs';
 export { getRandomString } from './src/getRandomString.mjs';
 export { debounce, throttle } from './src/performance.mjs';
+export { escapeRegExp } from './src/regexp/escapeRegExp.mjs';
+export { autoEscapedRegExp } from './src/regexp/autoEscapedRegExp.mjs';

package/mjs/src/getRandomString.mjs

@@ -1,5 +1,4 @@
-import { isPlainObject, isNumber, isNaN } from 'a-type-of-js';
-import { randomBytes } from 'crypto';
+import { isPlainObject, isNumber, isNaN, isUndefined } from 'a-type-of-js';
 
 /**
  * 获取随机字符串
@@ -10,30 +9,34 @@ import { randomBytes } from 'crypto';
  */
 /**
  *
- *  获取随机字符串
+ *  获取简单的随机字符串
  *
- *  @param   length - 字符串长度
+ *  @param   options - 字符串长度
  *  @returns  - 随机字符串
  *
  *
  */
-function getRandomString(length) {
+function getRandomString(options) {
     //   验证输入参数
     if (
     // 参数类型错误
-    (!isPlainObject(length) && !isNumber(length)) ||
+    (!isPlainObject(options) && !isNumber(options)) ||
         // 参数为 NaN
-        (isNumber(length) && isNaN(length)) ||
+        (isNumber(options) && isNaN(options)) ||
         // 参数为数字时为无穷大
-        (isNumber(length) && !isFinite(length)) ||
+        (isNumber(options) && !isFinite(options)) ||
         // 参数为数字时为非整数
-        (isNumber(length) && !Number.isInteger(length)) ||
+        (isNumber(options) && !Number.isInteger(options)) ||
         // 参数为数字时为负数
-        (isNumber(length) && Number.isInteger(length) && length < 1) ||
+        (isNumber(options) && Number.isInteger(options) && options < 1) ||
         // 参数为数值然而却小于 1
-        (isNumber(length) && length < 1) ||
-        (isPlainObject(length) && isNumber(length.length) && length.length < 1)) {
-        throw new TypeError('Invalid argument type (getRandomString)');
+        (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,
@@ -49,12 +52,12 @@ function getRandomString(length) {
     if (initOptions.type === 'uuid') {
         return crypto.randomUUID();
     }
-    if (isNumber(length) && Number.isInteger(length) && length > 0) {
+    if (isNumber(options) && Number.isInteger(options) && options > 0) {
         // 验证输入参数
-        Object.assign(initOptions, { length });
+        Object.assign(initOptions, { length: options });
     }
-    if (isPlainObject(length)) {
-        Object.assign(initOptions, length);
+    if (isPlainObject(options)) {
+        Object.assign(initOptions, options);
         initOptions.length = initOptions.length < 1 ? 32 : initOptions.length;
     }
     /**  生成随机字符串  */
@@ -72,7 +75,9 @@ function getRandomString(length) {
         interleaveString(templateCharsArr, initOptions.chars3);
     }
     // 使用密码学安全的随机数生成器
-    const bytes = randomBytes(initOptions.length);
+    const bytes = !isUndefined(window) && window.crypto
+        ? window.crypto.getRandomValues(new Uint8Array(initOptions.length))
+        : global.crypto.getRandomValues(new Uint8Array(initOptions.length));
     let result = '';
     /**  获取最后的 chars 数据  */
     const chars = templateCharsArr.join('');

package/mjs/src/performance.mjs

@@ -63,7 +63,7 @@ function debounce(callback, delay = 200) {
  */
 function throttle(callback, delay = 200) {
     // 强制转换非数值
-    if (!isFinite(delay) || (isFinite(delay) && delay < 0))
+    if (!isFinite(delay) || (isFinite(delay) && delay < 4))
         delay = 200;
     /**  延迟控制插销   */
     let inThrottle = false;

package/mjs/src/regexp/autoEscapedRegExp.mjs

@@ -0,0 +1,48 @@
+import { isString, isUndefined } from 'a-type-of-js';
+import { escapeRegExp } from './escapeRegExp.mjs';
+import { parse } from './parse.mjs';
+
+/**
+ *
+ * ##  适用于简单的文本字符串自动转化为简单模式正则表达式
+ *
+ * *若字符串包含且需保留字符类、组、反向引用、量词等时，该方法可能不适用*
+ *
+ * @param pattern 待转化的文本字符串
+ * @param options 转化选项。 为文本字符串时，默认为正则表达式的标志，还可指定是否匹配开头或结尾
+ * @returns 正则表达式
+ * @example
+ *
+ * ```ts
+ * import { autoEscapedRegExp } from 'a-regexp';
+ *
+ * autoEscapedRegExp('abc'); // => /abc/
+ * autoEscapedRegExp('abc', 'gim'); // => /abc/gim
+ * autoEscapedRegExp('abc',  { flags: 'g', start: true }); // => /^abc/g
+ * autoEscapedRegExp('abc',  { flags: 'g', end: true }); // => /abc$/g
+ * autoEscapedRegExp('abc',  { start: true, end: true }); // => /^abc$/
+ *
+ * // 转化特殊字符类、组、反向引用、量词等
+ * // 无法保留匹配规则
+ * autoEscapedRegExp('a-zA-Z0-9'); // => /a-zA-Z0-9/
+ * 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)) {
+        throw new TypeError('pattern must be a 字符串');
+    }
+    pattern = escapeRegExp(pattern);
+    /** 简单转化  */
+    if (isUndefined(options)) {
+        return new RegExp(pattern);
+    }
+    options = parse(options);
+    return new RegExp(`${options.start ? '^' : ''}${pattern}${options.end ? '$' : ''}`, options.flags);
+}
+
+export { autoEscapedRegExp };

package/mjs/src/regexp/escapeRegExp.mjs

@@ -0,0 +1,22 @@
+/**
+ *
+ * 将一个字符串转化为符合正则要求的字符串
+ *
+ * @param str 需要转义的字符串
+ * @requires escapeRegExp 转化后字符串
+ * @example
+ *
+ * ```ts
+ *  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\\$'
+ * ```
+ */
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+export { escapeRegExp };

package/mjs/src/regexp/parse.mjs

@@ -0,0 +1,33 @@
+import { isString, isNull } from 'a-type-of-js';
+
+/**
+ *
+ * 解析 options
+ *
+ */
+function parse(options) {
+    // 处理 options
+    if (isString(options)) {
+        options = {
+            flags: options,
+        };
+    }
+    // 处理 flags
+    if (!isString(options.flags)) {
+        options.flags = '';
+    }
+    else {
+        // 需求是保留字符串中的某一部分，使用
+        const regexp = /[migsuy]/g;
+        const matchResult = options.flags.match(regexp);
+        if (isNull(matchResult)) {
+            options.flags = '';
+        }
+        else {
+            options.flags = [...new Set(matchResult)].join('');
+        }
+    }
+    return options;
+}
+
+export { parse };

package/package.json

@@ -1,6 +1,6 @@
 {
   "type": "module",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "name": "a-js-tools",
   "description": "一点点 🤏  js 函数",
   "license": "ISC",

package/types/index.d.ts

@@ -1,3 +1,4 @@
 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';

package/types/src/getRandomString.d.ts

@@ -1,8 +1,6 @@
 /**
  *
- *  Random string generation function
- *
- *
+ *  随机字符串 生成器
  *
  */
 export type RandomStringOptions = {
@@ -46,11 +44,11 @@ export type RandomStringOptions = {
 };
 /**
  *
- *  获取随机字符串
+ *  获取简单的随机字符串
  *
- *  @param   length - 字符串长度
+ *  @param   options - 字符串长度
  *  @returns  - 随机字符串
  *
  *
  */
-export declare function getRandomString(length?: RandomStringOptions | number): string;
+export declare function getRandomString(options?: RandomStringOptions | number): string;

package/types/src/regexp/autoEscapedRegExp.d.ts

@@ -0,0 +1,32 @@
+import { autoEscapedRegExpOptions } from './types';
+/**
+ *
+ * ##  适用于简单的文本字符串自动转化为简单模式正则表达式
+ *
+ * *若字符串包含且需保留字符类、组、反向引用、量词等时，该方法可能不适用*
+ *
+ * @param pattern 待转化的文本字符串
+ * @param options 转化选项。 为文本字符串时，默认为正则表达式的标志，还可指定是否匹配开头或结尾
+ * @returns 正则表达式
+ * @example
+ *
+ * ```ts
+ * import { autoEscapedRegExp } from 'a-regexp';
+ *
+ * autoEscapedRegExp('abc'); // => /abc/
+ * autoEscapedRegExp('abc', 'gim'); // => /abc/gim
+ * autoEscapedRegExp('abc',  { flags: 'g', start: true }); // => /^abc/g
+ * autoEscapedRegExp('abc',  { flags: 'g', end: true }); // => /abc$/g
+ * autoEscapedRegExp('abc',  { start: true, end: true }); // => /^abc$/
+ *
+ * // 转化特殊字符类、组、反向引用、量词等
+ * // 无法保留匹配规则
+ * autoEscapedRegExp('a-zA-Z0-9'); // => /a-zA-Z0-9/
+ * 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\]\$/
+ *
+ * ```
+ *
+ */
+export declare function autoEscapedRegExp(pattern: string, options?: string | autoEscapedRegExpOptions): RegExp;

package/types/src/regexp/escapeRegExp.d.ts

@@ -0,0 +1,18 @@
+/**
+ *
+ * 将一个字符串转化为符合正则要求的字符串
+ *
+ * @param str 需要转义的字符串
+ * @requires escapeRegExp 转化后字符串
+ * @example
+ *
+ * ```ts
+ *  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\\$'
+ * ```
+ */
+export declare function escapeRegExp(str: string): string;

package/types/src/regexp/index.d.ts

@@ -0,0 +1,2 @@
+export { escapeRegExp } from './escapeRegExp';
+export { autoEscapedRegExp } from './autoEscapedRegExp';

package/types/src/regexp/parse.d.ts

@@ -0,0 +1,7 @@
+import { autoEscapedRegExpOptions } from './types';
+/**
+ *
+ * 解析 options
+ *
+ */
+export declare function parse(options: string | autoEscapedRegExpOptions): autoEscapedRegExpOptions;

package/types/src/regexp/types.d.ts

@@ -0,0 +1,15 @@
+export interface autoEscapedRegExpOptions {
+    /**
+     *
+     *
+     *
+     */
+    flags?: string;
+    /**
+     *
+     * 匹配开头
+     *
+     */
+    start?: boolean;
+    end?: boolean;
+}