@csqcsq/utils 1.0.13

package/aioxs/cachePlugin/index.ts

@@ -0,0 +1,124 @@
+import { getRequestKey } from "../createRequest";
+import type { AxiosResponse } from "axios";
+import type { PluginCallbackParams, RequestKey } from "../createRequest";
+
+interface CacheStore {
+  set: (key: string, value: any, keyPreFix?: string) => any;
+  get: (key: string, keyPreFix?: string) => any;
+}
+
+type CacheStoreType = "localStorage" | "sessionStorage" | CacheStore;
+
+export interface ExtendRequestConfig {
+  cache?: boolean;
+  cacheStore?: CacheStoreType;
+  cacheKey?: RequestKey;
+}
+interface PluginConfig {
+  storageKeyFix?: string;
+  transformCache?: (response: AxiosResponse) => { cache: boolean; data?: any };
+}
+
+const cacheSet: { [key: string]: any } = {};
+const cachePromiseSet: { [key: string]: Promise<any> } = {};
+
+declare global {
+  interface RequestConfigExt extends ExtendRequestConfig {}
+}
+
+const createrStorager = (
+  target: typeof localStorage | typeof sessionStorage,
+) => ({
+  set(key: string, value: any) {
+    target.setItem(key, JSON.stringify(value));
+  },
+  get(key: string) {
+    const value = target.getItem(key);
+
+    if (value) {
+      return JSON.parse(value);
+    }
+  },
+  remove(key: string) {
+    target.removeItem(key);
+  },
+});
+
+const createCacheStore = (cacheStore?: CacheStoreType): CacheStore => {
+  if (cacheStore === "localStorage") {
+    return createrStorager(localStorage);
+  }
+
+  if (cacheStore === "sessionStorage") {
+    return createrStorager(sessionStorage);
+  }
+
+  if (typeof cacheStore === "object") {
+    return cacheStore as CacheStore;
+  }
+
+  return {
+    set: (key, value) => (cacheSet[key] = value),
+    get: (key) => cacheSet[key],
+  };
+};
+
+// 缓存，可以指定缓存仓库，最大缓存接口数。TODO：添加数据过期时间
+export default function cachePlugin(pluginConfig?: PluginConfig) {
+  const {
+    storageKeyFix = "",
+    transformCache = (response: AxiosResponse) => ({
+      cache: true,
+      data: response,
+    }),
+  } = pluginConfig || {};
+
+  return ({
+    config,
+    beforeRequest,
+    afterRequest,
+    onResponse,
+  }: PluginCallbackParams) => {
+    const { cache, cacheKey, cacheStore } = config;
+
+    if (cache) {
+      const requestKey = getRequestKey(config, cacheKey);
+
+      const _cacheStore = createCacheStore(cacheStore);
+
+      beforeRequest((next) => {
+        const cachePromise = cachePromiseSet[requestKey];
+
+        const cacheData = _cacheStore.get(requestKey, storageKeyFix);
+
+        if (cachePromise) {
+          // 中断请求，复用上一个请求的promise
+          next(cachePromise.then(transformCache));
+        } else if (cacheData) {
+          // 中断请求，返回缓存数据
+          next(cacheData);
+        }
+      });
+
+      afterRequest((promise) => {
+        cachePromiseSet[requestKey] = promise;
+
+        promise.finally(() => {
+          // 完成请求，清空内存
+          delete cachePromiseSet[requestKey];
+        });
+      });
+
+      onResponse((response) => {
+        // 判断后端返回的结果是否正确 -> 将响应缓存起来
+        const { cache, data } = transformCache(response);
+
+        if (cache) {
+          _cacheStore.set(requestKey, data, storageKeyFix);
+        }
+
+        return response;
+      });
+    }
+  };
+}

package/aioxs/cancelPlugin/index.ts

@@ -0,0 +1,109 @@
+import { getRequestKey } from "../createRequest";
+import type { PluginCallbackParams } from "../createRequest";
+
+interface PluginConfig {
+  onIntercept?: (msg: string) => any;
+}
+
+export interface ExtendRequestConfig {
+  uuid?: string;
+  racekey?: string;
+  raceCancelMsg?: string;
+}
+
+interface RequestItem {
+  uuid: string;
+  controller: AbortController;
+  racekey?: string;
+}
+
+declare global {
+  interface RequestConfigExt extends ExtendRequestConfig {}
+}
+
+const requestList: RequestItem[] = [];
+
+const getRequestIndex = (key: string, racekey?: string) => {
+  return requestList?.findIndex((item) => {
+    return racekey
+      ? item.uuid === key && item.racekey === racekey
+      : item.uuid === key;
+  });
+};
+
+// 取消所有请求
+export const cancelAllRequest = () => {
+  requestList.map((request) => request.controller.abort());
+};
+
+// 取消指定请求
+export const cancelRequest = (target: string | string[]) => {
+  if (typeof target === "string") {
+    // 取消当个请求
+    const sourceIndex = getRequestIndex(target);
+
+    sourceIndex >= 0 && requestList[sourceIndex]?.controller.abort();
+  } else {
+    target.forEach((uuid) => {
+      const sourceIndex = getRequestIndex(uuid);
+
+      sourceIndex >= 0 && requestList[sourceIndex]?.controller.abort();
+    });
+  }
+};
+
+// 取消接口请求插件
+export default function cancelPlugin(pluginConfig?: PluginConfig) {
+  const { onIntercept } = pluginConfig || {};
+
+  return ({ config, beforeRequest, afterRequest }: PluginCallbackParams) => {
+    const { signal, racekey, raceCancelMsg, uuid } = config;
+
+    if (signal) {
+      console.warn(
+        `当前请求接口${config.url} --- 竞态取消/全局统一取消功能失效`,
+      );
+
+      return;
+    }
+
+    const requestkey = uuid || getRequestKey(config);
+
+    const controller = new AbortController();
+
+    const requestItem: RequestItem = { uuid: requestkey, racekey, controller };
+
+    beforeRequest(() => {
+      // 增加取消的配置
+      return { ...config, signal: controller.signal };
+    });
+
+    afterRequest((promise) => {
+      // 需要竞态取消
+      if (racekey) {
+        const sourceIndex = getRequestIndex(requestkey, racekey);
+
+        // 如果前面有未取消的请求，则执行取消
+        if (sourceIndex >= 0) {
+          const msg = raceCancelMsg || "竞态取消";
+
+          onIntercept && onIntercept(msg);
+
+          requestList[sourceIndex]?.controller.abort();
+        }
+      }
+
+      // 将当前请求存入，让下一次请求能执行取消当前请求
+      requestList.push(requestItem);
+
+      // 当前请求响应后，清除对应的requestItem
+      promise.finally(() => {
+        const sourceIndex = requestList.findIndex(
+          (item) => item === requestItem,
+        );
+
+        sourceIndex >= 0 && requestList.splice(sourceIndex, 1);
+      });
+    });
+  };
+}

package/aioxs/concurrencyPlugin/index.ts

@@ -0,0 +1,44 @@
+import type { PluginCallbackParams } from "../createRequest";
+
+export interface ExtendRequestConfig {
+  concurrencyKey?: string;
+  concurrencyMsg?: string;
+}
+
+declare global {
+  interface RequestConfigExt extends ExtendRequestConfig {}
+}
+
+interface PluginConfig {
+  handleTips?: (msg: string) => any;
+}
+
+const pendingMap: { [key: string]: boolean } = {};
+
+// 并发限制(请求1未响应，请求2无法发出)
+export default function concurrencyPlugin(pluginConfig?: PluginConfig) {
+  const { handleTips } = pluginConfig || {};
+
+  return ({ config, beforeRequest, afterRequest }: PluginCallbackParams) => {
+    const { concurrencyKey, concurrencyMsg } = config;
+
+    if (concurrencyKey) {
+      beforeRequest((next) => {
+        // 如果前面接口还处于pending状态，则不要发出请求
+        if (pendingMap[concurrencyKey]) {
+          const msg = concurrencyMsg || "操作频繁";
+
+          handleTips && handleTips(msg);
+
+          next(Promise.reject({ message: msg }));
+        }
+      });
+
+      afterRequest((promise) => {
+        pendingMap[concurrencyKey] = true;
+
+        promise.finally(() => delete pendingMap[concurrencyKey]);
+      });
+    }
+  };
+}

package/aioxs/createAxios/index.ts

@@ -0,0 +1,59 @@
+import createRequest from "../createRequest";
+import type { RequestConfig, Request } from "../createRequest";
+
+export type Method = "get" | "post" | "put" | "delete" | "patch";
+
+export interface MethodRequest {
+  <P extends object = any, T = any>(
+    url: string,
+    baseParams?: P,
+    baseConfig?: RequestConfig,
+  ): (params?: P, config?: RequestConfig) => Promise<T>;
+}
+
+// 请求方法集合
+export interface AxiosMethods {
+  get: MethodRequest;
+  post: MethodRequest;
+  put: MethodRequest;
+  delete: MethodRequest;
+  patch: MethodRequest;
+}
+
+export function createMethodRequst(request: Request, method: Method) {
+  return <P = AnalyserNode, T = any>(
+    url: string,
+    baseParams?: P,
+    baseConfig?: RequestConfig,
+  ) => {
+    return (params?: P, config?: RequestConfig): Promise<T> => {
+      const paramKey = ["post", "put", "patch"].includes(method)
+        ? "data"
+        : "params";
+
+      return request({
+        ...config,
+        ...baseConfig,
+        url,
+        method,
+        [paramKey]: baseParams ? { ...baseParams, ...params } : params,
+      });
+    };
+  };
+}
+
+const createAxios = (config: RequestConfig) => {
+  const { request, axiosInstance } = createRequest(config);
+
+  const axios: AxiosMethods = {
+    get: createMethodRequst(request, "get"),
+    post: createMethodRequst(request, "post"),
+    put: createMethodRequst(request, "put"),
+    delete: createMethodRequst(request, "delete"),
+    patch: createMethodRequst(request, "patch"),
+  };
+
+  return { axios, request, axiosInstance };
+};
+
+export default createAxios;

package/aioxs/createRequest/index.ts

@@ -0,0 +1,179 @@
+import axios from "axios";
+
+import type { AxiosRequestConfig } from "axios";
+
+declare global {
+  interface RequestConfigExt {}
+}
+
+// 请求配置扩展
+export type RequestConfig = AxiosRequestConfig & RequestConfigExt;
+
+// 插件类型
+export interface Plugin {
+  ({
+    beforeRequest,
+    afterRequest,
+    onResponse,
+    config,
+  }: PluginCallbackParams): void;
+}
+
+export interface Request {
+  <T>(config: RequestConfig): Promise<T>;
+  use: (plugin: Plugin) => void;
+}
+
+// 请求拦截器
+interface RequestInterceptor {
+  (
+    next: (value?: any) => void,
+  ): RequestConfig | void | Promise<void | RequestConfig>;
+}
+
+// 请求监听器
+interface RequestListener {
+  (promise: Promise<any>): void;
+}
+
+// 响应正常处理
+interface ResponseResolver {
+  (res: any): any;
+}
+
+// 响应错误处理
+interface ResponseRejecter {
+  (err: any): any;
+}
+
+// 请求监听参数
+export interface PluginCallbackParams {
+  beforeRequest: (requestInterceptor: RequestInterceptor) => void;
+  afterRequest: (requestListener: RequestListener) => void;
+  onResponse: (resolve: ResponseResolver, reject?: ResponseRejecter) => void;
+  config: RequestConfig;
+}
+
+// 请求key
+export type RequestKey =
+  | "url"
+  | "urlParams"
+  | ((config: RequestConfig) => string);
+
+/**
+ * 获取请求key，可以配置params、header是否参与计算，也可以自定义生成id的方法将该方法覆盖
+ * @param config 请求配置
+ * @param key 请求key
+ * @returns 数据
+ */
+export const getRequestKey = (
+  config: RequestConfig,
+  key: RequestKey = "url",
+) => {
+  const { url, params, data } = config;
+
+  if (typeof key === "function") {
+    return key(config);
+  }
+
+  const createObj: any = { url };
+
+  if (key === "urlParams") createObj.params = Object.assign({}, params, data);
+
+  return JSON.stringify(createObj);
+};
+
+// 创建请求
+export default function createRequest(axiosConfig: RequestConfig) {
+  const axiosInstance = axios.create(axiosConfig);
+
+  const plugins: Plugin[] = [];
+
+  // 请求方法
+  const request: Request = <T>(config: RequestConfig): Promise<T> => {
+    // 请求拦截器（这个阶段可以种植请求，可以自定义返回请求等）
+    const requestInterceptors: RequestInterceptor[] = [];
+
+    const beforeRequest = (requestInterceptor: RequestInterceptor) =>
+      requestInterceptors.push(requestInterceptor);
+
+    // 请求监听（这个阶段可以获取请求的promise/abort等）
+    const requestListeners: RequestListener[] = [];
+
+    const afterRequest = (requestListener: RequestListener) =>
+      requestListeners.push(requestListener);
+
+    // 响应拦截（这个阶段可以对最终返回结果进行操作，同axios响应拦截器）
+    const responseInterceptors: [
+      RequireResolve,
+      ResponseRejecter | undefined,
+    ][] = [];
+
+    const onResponse = (resolve: RequireResolve, reject?: ResponseRejecter) =>
+      responseInterceptors.push([resolve, reject]);
+
+    // 添加插件
+    plugins.forEach((callback) =>
+      callback({ beforeRequest, afterRequest, onResponse, config }),
+    );
+
+    return new Promise<T>(async (resolve) => {
+      // 处理请求之前
+      const handleBeforeRequest = async () => {
+        let needRequest = true;
+        let isBail = false;
+
+        for (
+          let i = 0, len = requestInterceptors?.length;
+          i < len && !isBail;
+          i++
+        ) {
+          const interceptor: RequestInterceptor | undefined =
+            requestInterceptors[i];
+
+          if (interceptor) {
+            const _config = await interceptor((value?: any) => {
+              if (value !== undefined) {
+                isBail = true;
+                needRequest = false;
+                return resolve(value);
+              }
+            });
+
+            Object.assign(config, _config);
+          }
+        }
+
+        return needRequest;
+      };
+
+      // 请求被拦截，阻止发送请求
+      if (!(await handleBeforeRequest())) return;
+
+      // 防止缓存
+      if (config.method === "get" || config.method === "delete") {
+        if (config.params) {
+          config.params._t = new Date().getTime();
+        } else {
+          config.params = { _t: new Date().getTime() };
+        }
+      }
+
+      let promise: Promise<any> = axiosInstance(config);
+
+      // 通过反复复制 promise，实现响应拦截的值处理
+      responseInterceptors.forEach((handlers) => {
+        promise = promise.then(handlers[0], handlers[1]);
+      });
+
+      // 遍历请求监听器
+      requestListeners.forEach((listener) => listener(promise));
+
+      return resolve(promise);
+    });
+  };
+
+  request.use = (plugin: Plugin) => plugins.push(plugin);
+
+  return { request, axiosInstance };
+}

package/aioxs/flatResponsePlugin/index.ts

@@ -0,0 +1,20 @@
+import type { PluginCallbackParams } from "../createRequest";
+
+export interface ExtendRequestConfig {
+  flat?: boolean;
+}
+
+declare global {
+  interface RequestConfigExt extends ExtendRequestConfig {}
+}
+
+// 拉平响应，去除data外面那一层
+export default function flatResponsePlugin() {
+  return ({ config, onResponse }: PluginCallbackParams) => {
+    const { flat } = config;
+
+    if (flat !== false) {
+      onResponse((response) => response?.data || response);
+    }
+  };
+}

package/aioxs/loadingPlugin/index.ts

@@ -0,0 +1,26 @@
+import type { PluginCallbackParams } from "../createRequest";
+
+export interface ExtendRequestConfig {
+  loading?: boolean;
+}
+
+declare global {
+  interface RequestConfigExt extends ExtendRequestConfig {}
+}
+
+export type LoadingFunc = () => { close: Function };
+
+// 加载中的插件
+export default function loadingPlugin(loadingFunc: LoadingFunc) {
+  return ({ config, afterRequest }: PluginCallbackParams) => {
+    const { loading } = config;
+
+    if (loading) {
+      afterRequest((promise: Promise<any>) => {
+        const loadingInstance = loadingFunc();
+
+        promise.catch(() => {}).finally(() => loadingInstance.close());
+      });
+    }
+  };
+}

package/aioxs/messagePlugin/index.ts

@@ -0,0 +1,45 @@
+import type { PluginCallbackParams } from "../createRequest";
+
+export interface ExtendRequestConfig {
+  successTip?: boolean;
+  errorTip?: boolean;
+  defaultMsg?: boolean;
+  defaultErrMsg?: string;
+}
+
+declare global {
+  interface RequestConfigExt extends ExtendRequestConfig {}
+}
+
+export interface MessagePluginParams {
+  successTipFun?: (msg: string) => void;
+  errorTipFun?: (msg: string) => void;
+  successCodeList?: number[];
+}
+
+/**
+ * 统一提示插件
+ * @param param0 { successTipFun = console.log, errorTipFun = console.error, successCodeList = [200] }
+ */
+export default function messagePlugin({
+  successTipFun = console.log,
+  errorTipFun = console.error,
+  successCodeList = [200],
+}: MessagePluginParams = {}) {
+  return ({ onResponse, config }: PluginCallbackParams) => {
+    const { errorTip, successTip, defaultMsg, defaultErrMsg } = config;
+
+    onResponse((response) => {
+      const { code, msg, message } = response || {};
+
+      // 默认成功不提示，除非用户自己配置提示
+      if (successTip || successCodeList.includes(code)) {
+        successTipFun(msg || message || defaultErrMsg || "请求成功");
+      } else if (errorTip !== false && !successCodeList.includes(code)) {
+        errorTipFun(msg || message || defaultMsg || "未知错误");
+      }
+
+      return response;
+    });
+  };
+}

package/index.ts

@@ -0,0 +1,63 @@
+import { formatDate, dateDiff } from './modules/dateUtil'
+
+import {
+  isEmptyString,
+  birsdayToAge,
+  getType,
+  isNumber,
+  isArray,
+  isArrayEmpty,
+  deepClone,
+  filterEmptyData,
+  round,
+  commafy,
+  numberPad,
+  numberRandom,
+  hideMobile,
+  strTrim,
+  checkPwd,
+  randomNumber
+} from './modules/utils'
+
+import { isPhone, isIdCard, isVehicleNumber } from './modules/validateUtils'
+
+import cachePlugin from './aioxs/cachePlugin'
+import cancelPlugin from './aioxs/cancelPlugin'
+import concurrencyPlugin from './aioxs/concurrencyPlugin'
+import createAxios from './aioxs/createAxios'
+import createRequest from './aioxs/createRequest'
+import flatResponsePlugin from './aioxs/flatResponsePlugin'
+import loadingPlugin from './aioxs/loadingPlugin'
+import messagePlugin from './aioxs/messagePlugin'
+
+export {
+  cachePlugin,
+  cancelPlugin,
+  concurrencyPlugin,
+  createAxios,
+  createRequest,
+  flatResponsePlugin,
+  loadingPlugin,
+  messagePlugin,
+  formatDate,
+  dateDiff,
+  isEmptyString,
+  birsdayToAge,
+  getType,
+  isNumber,
+  isArray,
+  isArrayEmpty,
+  deepClone,
+  filterEmptyData,
+  round,
+  commafy,
+  numberPad,
+  numberRandom,
+  hideMobile,
+  strTrim,
+  checkPwd,
+  randomNumber,
+  isPhone,
+  isIdCard,
+  isVehicleNumber
+}

package/modules/dateUtil.ts

@@ -0,0 +1,25 @@
+import dayjs from "dayjs";
+
+/**
+ * 格式化日期
+ * @param date 时间
+ * @param formatString 时间格式
+ */
+export function formatDate(date: Date, formatString: string): string {
+  return dayjs(date).format(formatString);
+}
+
+//
+/**
+ * 用于计算两个日期之间的差值
+ * @param start 开始时间
+ * @param end 结束时间
+ * @param unit dayjs.OpUnitType
+ */
+export function dateDiff(
+  start: Date,
+  end: Date,
+  unit: dayjs.OpUnitType,
+): number {
+  return dayjs(end).diff(dayjs(start), unit);
+}

package/modules/utils.ts

@@ -0,0 +1,242 @@
+interface InterfaceObj {
+  [key: string]: any;
+}
+
+/**
+ * 验证字符串是否为空（也不能为纯空格）
+ * @param str 字符串
+ * @returns {boolean} true--说明为空， false--说明不为空
+ */
+export function isEmptyString(str: string) {
+  return (
+    str == undefined ||
+    typeof str == "undefined" ||
+    !str ||
+    str == "" ||
+    /^\s+$/gi.test(str)
+  );
+}
+
+/**
+ * 生日转为年龄（精确到月份）
+ * @param birsday 生日
+ * @returns {string}
+ */
+export function birsdayToAge(birsday: string) {
+  const aDate = new Date();
+
+  const thisYear = aDate.getFullYear();
+
+  const bDate = new Date(birsday);
+
+  const brith = bDate.getFullYear();
+
+  let age = thisYear - brith;
+
+  if (aDate.getMonth() == bDate.getMonth()) {
+    if (aDate.getDate() < bDate.getDate()) {
+      age = age - 1;
+    }
+  } else {
+    if (aDate.getMonth() < bDate.getMonth()) {
+      age = age - 1;
+    }
+  }
+
+  return age;
+}
+
+/**
+ * 判断数据类型
+ * @param {any} val - 基本类型数据或者引用类型数据
+ * @return {string} - 可能返回的结果有，均为小写字符串
+ * number、boolean、string、null、undefined、array、object、function等
+ */
+export function getType(val: any) {
+  //判断数据是 null 和 undefined 的情况
+  if (val == null) return val + "";
+
+  //判断数据是 数组类型
+  return typeof val === "object"
+    ? Object.prototype.toString.call(val).slice(8, -1).toLowerCase()
+    : typeof val;
+}
+
+/**
+ * 验证是否为数字
+ * @param n
+ */
+export function isNumber(n: any) {
+  return !isNaN(parseFloat(n)) && isFinite(n);
+}
+
+/**
+ * 是否为数组
+ * @param obj
+ */
+export function isArray(obj: any) {
+  return Object.prototype.toString.call(obj) === "[object Array]";
+}
+
+/**
+ * 是否空数组
+ * @param val
+ */
+export function isArrayEmpty(val: any) {
+  return !(val && val instanceof Array && val.length > 0);
+}
+
+/**
+ * 递归深拷贝
+ * @param obj
+ */
+export function deepClone(obj: any) {
+  if (obj === null) return null;
+
+  if (typeof obj !== "object") return obj;
+
+  if (obj.constructor === Date) return new Date(obj);
+
+  if (obj.constructor === RegExp) return new RegExp(obj);
+
+  let newObj: any = new obj.constructor();
+
+  for (let key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      newObj[key] = deepClone(obj[key]);
+    }
+  }
+}
+
+/**
+ * 去除参数空数据（用于向后台传递参数的时候）
+ * @param obj  Object[参数对象]
+ */
+export function filterEmptyData(obj: InterfaceObj) {
+  for (let prop in obj) {
+    obj[prop] === "" ? delete obj[prop] : obj[prop];
+  }
+  return obj;
+}
+
+/**
+ * 数字四舍五入（保留n位小数）
+ * @param num 要处理的数字
+ * @param n 保留小数位数
+ * @returns 处理后的数字
+ */
+export function round(num: number, n: number = 0) {
+  if (n <= 0) {
+    return Math.round(num);
+  } else {
+    return Math.round(num * Math.pow(10, n)) / Math.pow(10, n);
+  }
+}
+
+/**
+ * 数字每千位加逗号
+ * @param num 数字
+ */
+export function commafy(num: number) {
+  return (
+    num &&
+    num.toString().replace(/\d+/, function (s) {
+      return s.replace(/(\d)(?=(\d{3})+$)/g, "$1,");
+    })
+  );
+}
+
+/**
+ * 数字补位,numberPad用于按照位数补0,默认为2
+ * @param source 数字
+ * @param length 补位位数
+ * @returns {string} 补位后的数字
+ */
+export function numberPad(source: number, length: number = 2) {
+  let pre = "";
+
+  const negative = source < 0;
+
+  const string = String(Math.abs(source));
+
+  if (string.length < length) {
+    pre = new Array(length - string.length + 1).join("0");
+  }
+
+  return (negative ? "-" : "") + pre + string;
+}
+
+/**
+ * 随机数
+ * @param min 最小值
+ * @param max 最大值
+ */
+export function numberRandom(min: number, max: number) {
+  return Math.floor(Math.random() * (max - min + 1) + min);
+}
+
+/**
+ * 手机号码中间4位隐藏花号（*）显示
+ * @param mobile 手机号
+ */
+export function hideMobile(mobile: string) {
+  return mobile.replace(/^(\d{3})\d{4}(\d{4})$/, "$1****$2");
+}
+
+/**
+ * 去除字符串空格
+ * @param str 要处理的字符串
+ * @param type 1：所有空格 2：前后空格 3：前空格 4：后空格
+ */
+export function strTrim(str: string, type: number) {
+  switch (type) {
+    case 1:
+      return str.replace(/\s+/g, "");
+    case 2:
+      return str.replace(/(^\s*)|(\s*$)/g, "");
+    case 3:
+      return str.replace(/(^\s*)/g, "");
+    case 4:
+      return str.replace(/(\s*$)/g, "");
+    default:
+      return str;
+  }
+}
+
+/**
+ * 检测密码强度
+ * @param str 字符串
+ * @returns 1：密码弱 2：密码中等 3：密码强 4：密码很强
+ */
+export function checkPwd(str: string) {
+  var nowLv = 0;
+  if (str.length < 6) {
+    return nowLv;
+  }
+  if (/[0-9]/.test(str)) {
+    nowLv++;
+  }
+  if (/[a-z]/.test(str)) {
+    nowLv++;
+  }
+  if (/[A-Z]/.test(str)) {
+    nowLv++;
+  }
+  return nowLv;
+}
+
+/**
+ * 返回指定某个区间的一个数字（可以不传参，不传就返回0-255之间的数；可以只传一个，返回0到传入的这个数字之间的某个值）
+ * @param n1 开始区间 例：5
+ * @param n2 结束区间 例：10
+ * @returns 返回这个区间的某个随机值
+ */
+export function randomNumber(n1: number, n2: number) {
+  if (arguments.length === 2) {
+    return Math.round(n1 + Math.random() * (n2 - n1));
+  } else if (arguments.length === 1) {
+    return Math.round(Math.random() * n1);
+  } else {
+    return Math.round(Math.random() * 255);
+  }
+}

package/modules/validateUtils.ts

@@ -0,0 +1,36 @@
+/**
+ * 验证手机号是否合格
+ * @param phoneStr 手机号
+ * @returns {boolean} true--说明合格
+ */
+export function isPhone(phoneStr: string) {
+  return !phoneStr;
+}
+
+/**
+ * 验证身份证号是否合格
+ * @param idCard 身份证号
+ * @returns {boolean} true--说明合格
+ */
+export function isIdCard(idCard: string) {
+  return !idCard;
+}
+
+/**
+ * 验证车牌号是否合格
+ * @param vehicleNumber 车牌号
+ * @returns {boolean} true--说明合格
+ */
+export function isVehicleNumber(vehicleNumber: string) {
+  let xreg: RegExp =
+    /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}(([0-9]{5}[DF]$)|([DF][A-HJ-NP-Z0-9][0-9]{4}$))/;
+  let creg: RegExp =
+    /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}[A-HJ-NP-Z0-9]{4}[A-HJ-NP-Z0-9挂学警港澳]{1}$/;
+  if (vehicleNumber.length == 7) {
+    return creg.test(vehicleNumber);
+  } else if (vehicleNumber.length == 8) {
+    return xreg.test(vehicleNumber);
+  } else {
+    return false;
+  }
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@csqcsq/utils",
+  "version": "1.0.13",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "https://gitee.com/csq-cn/pnpm-monorepo"
+  },
+  "author": "csq",
+  "keywords": [
+    "utils",
+    "axios",
+    "format",
+    "money",
+    "phone"
+  ],
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.5.1",
+    "dayjs": "^1.11.10",
+    "typescript": "^5.0.2"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,81 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "target": "esnext",
+    "useDefineForClassFields": true,
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "jsx": "preserve",
+    "baseUrl": "./",
+    "sourceMap": true,
+    // 目标语言的版本
+    // 生成代码的模板标准
+    "lib": ["DOM", "ES5", "ES6", "ES7", "ScriptHost"],
+    // TS需要引用的库
+    "outDir": "./dist",
+    // 指定输出目录
+    "rootDir": "./",
+    // 指定输出文件目录(用于输出)，用于控制输出目录结构
+    "allowJs": true,
+    // 允许编译器编译JS，JSX文件
+    "checkJs": true,
+    // 允许在JS文件中报错，通常与allowJS一起使用
+    "removeComments": true,
+    // 删除注释
+    "esModuleInterop": true,
+    // 允许export=导出，由import from 导入
+
+    /* 严格检查选项 */
+    "strict": true,
+    // 开启所有严格的类型检查
+    "alwaysStrict": true,
+    // 在代码中注入'use strict'
+    "noImplicitAny": true,
+    // 不允许隐式的any类型
+    "noImplicitThis": true,
+    // 不允许this有隐式的any类型
+    "strictNullChecks": true,
+    // 不允许把null、undefined赋值给其他类型的变量
+    "strictBindCallApply": true,
+    // 严格的bind/call/apply检查
+    "strictFunctionTypes": true,
+    // 不允许函数参数双向协变
+    "strictPropertyInitialization": true,
+    // 类的实例属性必须初始化
+
+    /* 额外检查 */
+    "noUnusedLocals": false,
+    //是否检查未使用的局部变量
+    "noUnusedParameters": false,
+    //是否检查未使用的参数
+    "noImplicitReturns": true,
+    //检查函数是否不含有隐式返回值
+    "noImplicitOverride": true,
+    //是否检查子类继承自基类时，其重载的函数命名与基类的函数不同步问题
+    "noFallthroughCasesInSwitch": true,
+    //检查switch中是否含有case没有使用break跳出
+    "noUncheckedIndexedAccess": true,
+    //是否通过索引签名来描述对象上有未知键但已知值的对象
+    "noPropertyAccessFromIndexSignature": true,
+    //是否通过" . “(obj.key) 语法访问字段和"索引”( obj[“key”])， 以及在类型中声明属性的方式之间的一致性
+
+    /* 实验选项 */
+    "experimentalDecorators": true,
+    //是否启用对装饰器的实验性支持，装饰器是一种语言特性，还没有完全被 JavaScript 规范批准
+    "emitDecoratorMetadata": true,
+    //为装饰器启用对发出类型元数据的实验性支持
+
+    /* 高级选项 */
+    "forceConsistentCasingInFileNames": true,
+    //是否区分文件系统大小写规则
+    "extendedDiagnostics": false,
+    //是否查看 TS 在编译时花费的时间
+    "noEmitOnError": true,
+    //有错误时不进行编译
+    "resolveJsonModule": true,
+    //是否解析 JSON 模块
+    "types": ["node"]
+  },
+  "exclude": ["node_modules", "dist"],
+  "include": ["./**/*.ts"]
+}

package//346/217/220/344/272/244/346/217/222/344/273/266/346/226/207/346/241/243.md

@@ -0,0 +1,29 @@
+### 登录
+
+```
+npm login
+```
+
+### 发布包
+
+```
+npm publish --access public
+```
+
+### 删除已发布的包
+
+```
+npm unpublish <package-name>@<version>
+```
+
+### 撤销发布
+
+```
+npm unpublish <package-name>@<version> --force
+```
+
+### 修改版本号
+
+```
+npm version <newversion>
+```