zmdms-utils 0.0.21 → 0.0.23

package/dist/es/_virtual/parseTimeTest.js

@@ -0,0 +1,3 @@
+var parseTimeTest = {};
+
+export { parseTimeTest as __exports };

package/dist/es/_virtual/test.js

@@ -0,0 +1,3 @@
+var test = {};
+
+export { test as __exports };

package/dist/es/parseTime.d.ts

@@ -0,0 +1,25 @@
+type IType = "string" | "object";
+type IEndType = "startOf" | "endOf";
+interface IConfig {
+    params: string | number | object;
+    format?: string | string[];
+    type?: IType | IType[];
+    fromKeys?: Array<string | string[]>;
+    toKeys?: Array<string | string[]>;
+    endType?: Array<IEndType | IEndType[]>;
+}
+/**
+ * 解析时间
+ * 可能转换的结果
+ * 日期对象转字符串
+ * Dayjs => "20xx-xx-xx"
+ * { key: Dayjs } => { key: "20xx-xx-xx" }
+ * { mergeKey: [Dayjs, Dayjs] } => { key1: "20xx-xx-xx", key2: "20xx-xx-xx" }
+ * 字符串转日期对象
+ * "20xx-xx-xx" => Dayjs
+ * { key: "20xx-xx-xx" } => { key: Dayjs }
+ * { key1: "20xx-xx-xx", key1: "20xx-xx-xx" } => { mergeKey: [Dayjs, Dayjs] }
+ */
+declare function parseTime(config: IConfig): any;
+
+export { parseTime as default };

package/dist/es/parseTime.js

@@ -0,0 +1,170 @@
+import dayjs from 'dayjs';
+
+var defaultFormat = "YYYY-MM-DD";
+/**
+ * 解析时间
+ * 可能转换的结果
+ * 日期对象转字符串
+ * Dayjs => "20xx-xx-xx"
+ * { key: Dayjs } => { key: "20xx-xx-xx" }
+ * { mergeKey: [Dayjs, Dayjs] } => { key1: "20xx-xx-xx", key2: "20xx-xx-xx" }
+ * 字符串转日期对象
+ * "20xx-xx-xx" => Dayjs
+ * { key: "20xx-xx-xx" } => { key: Dayjs }
+ * { key1: "20xx-xx-xx", key1: "20xx-xx-xx" } => { mergeKey: [Dayjs, Dayjs] }
+ */
+function parseTime(config) {
+    var params = config.params, _a = config.format, format = _a === void 0 ? defaultFormat : _a, _b = config.type, type = _b === void 0 ? "string" : _b, _c = config.fromKeys, fromKeys = _c === void 0 ? [] : _c, _d = config.toKeys, toKeys = _d === void 0 ? [] : _d, endType = config.endType;
+    // 获取最终结果
+    var getParseResult = parseByResult({ format: format, type: type });
+    // 如果传入的是一个字符串(就是单字段)
+    if (typeof params === "string" || typeof params === "number") {
+        // 1. 结果类型是一个日期对象
+        // 2. 如果结果类型是字符串，那么字符串转字符串可能的一个场景是：将一个日期格式的数据转成另外一种格式的日期
+        return getParseResult({
+            value: params,
+            endType: typeof endType === "string" ? endType : undefined,
+        });
+    }
+    else {
+        // 浅拷贝一下
+        var newParams_1 = Object.assign({}, params);
+        fromKeys.forEach(function (fromKey, index) {
+            var toKey = toKeys[index];
+            var endTypeItem = Array.isArray(endType) ? endType[index] : endType;
+            // 1. 从一个键 转成 一个键
+            if (typeof fromKey === "string" && typeof toKey === "string") {
+                newParams_1[toKey] = getParseResult({
+                    value: newParams_1[fromKey],
+                    index: index,
+                    endType: endTypeItem,
+                });
+                if (fromKey !== toKey) {
+                    // 删除原有key
+                    Reflect.deleteProperty(newParams_1, fromKey);
+                }
+            }
+            // 2. 从一个键 转成 两个键
+            if (typeof fromKey === "string" && typeof toKey === "object") {
+                var toKey1 = toKey[0], toKey2 = toKey[1];
+                // 初始定义转义类型 是否拼接一天的开始 一天的结束
+                var startEndType = "startOf";
+                var endEndType = "endOf";
+                if (Array.isArray(endTypeItem)) {
+                    startEndType = endTypeItem[0];
+                    endEndType = endTypeItem[1];
+                }
+                newParams_1[toKey1] = getParseResult({
+                    value: newParams_1[fromKey],
+                    index: index,
+                    endType: startEndType,
+                });
+                newParams_1[toKey2] = getParseResult({
+                    value: newParams_1[fromKey],
+                    index: index,
+                    endType: endEndType,
+                });
+                if (fromKey !== toKey1 && fromKey !== toKey2) {
+                    Reflect.deleteProperty(newParams_1, fromKey);
+                }
+            }
+            // 3. 从两个键 转成 一个键
+            if (typeof fromKey === "object" && typeof toKey === "string") {
+                var fromKey1 = fromKey[0], fromtKey2 = fromKey[1];
+                // 初始定义转义类型 是否拼接一天的开始 一天的结束
+                var startEndType = "startOf";
+                var endEndType = "endOf";
+                if (Array.isArray(endTypeItem)) {
+                    startEndType = endTypeItem[0];
+                    endEndType = endTypeItem[1];
+                }
+                newParams_1[toKey] = [
+                    getParseResult({
+                        value: newParams_1[fromKey1],
+                        index: index,
+                        endType: startEndType,
+                    }),
+                    getParseResult({
+                        value: newParams_1[fromtKey2],
+                        index: index,
+                        endType: endEndType,
+                    }),
+                ];
+                if (fromKey1 !== toKey) {
+                    Reflect.deleteProperty(newParams_1, fromKey1);
+                }
+                if (fromtKey2 !== toKey) {
+                    Reflect.deleteProperty(newParams_1, fromtKey2);
+                }
+            }
+            // 4. 从两个键 转成 两个键
+            if (typeof fromKey === "object" && typeof toKey === "object") {
+                var fromKey1 = fromKey[0], fromtKey2 = fromKey[1];
+                var toKey1 = toKey[0], toKey2 = toKey[1];
+                // 初始定义转义类型 是否拼接一天的开始 一天的结束
+                var startEndType = undefined;
+                var endEndType = undefined;
+                if (Array.isArray(endTypeItem)) {
+                    startEndType = endTypeItem[0];
+                    endEndType = endTypeItem[1];
+                }
+                newParams_1[toKey1] = getParseResult({
+                    value: newParams_1[fromKey1],
+                    index: index,
+                    endType: startEndType,
+                });
+                newParams_1[toKey2] = getParseResult({
+                    value: newParams_1[fromtKey2],
+                    index: index,
+                    endType: endEndType,
+                });
+                if (fromKey1 !== toKey1) {
+                    // 删除原有key
+                    Reflect.deleteProperty(newParams_1, fromKey1);
+                }
+                if (fromtKey2 !== toKey2) {
+                    // 删除原有key
+                    Reflect.deleteProperty(newParams_1, fromtKey2);
+                }
+            }
+        });
+        return newParams_1;
+    }
+}
+function parseByResult(option) {
+    var _a = option.format, format = _a === void 0 ? defaultFormat : _a, _b = option.type, type = _b === void 0 ? "string" : _b;
+    return function (option) {
+        var value = option.value, _a = option.index, index = _a === void 0 ? 0 : _a, endType = option.endType;
+        if (!value) {
+            return undefined;
+        }
+        var parseType = typeof type === "string" ? type : type[index];
+        var parseFormat = typeof format === "string" ? format : format[index];
+        var parseEndType = Array.isArray(endType) ? endType[0] : endType;
+        if (parseType === "string") {
+            var dayjsValue = dayjs.isDayjs(value) ? value : dayjs(value);
+            if (parseEndType === "startOf") {
+                return dayjsValue
+                    .startOf("day")
+                    .format(parseFormat.length === 10 ? "".concat(parseFormat, " HH:mm:ss") : parseFormat);
+            }
+            if (parseEndType === "endOf") {
+                return dayjsValue
+                    .endOf("day")
+                    .format(parseFormat.length === 10 ? "".concat(parseFormat, " HH:mm:ss") : parseFormat);
+            }
+            return dayjsValue.format(parseFormat);
+        }
+        else {
+            if (parseEndType === "startOf") {
+                return dayjs(value).startOf("day");
+            }
+            if (parseEndType === "endOf") {
+                return dayjs(value).endOf("day");
+            }
+            return dayjs(value);
+        }
+    };
+}
+
+export { parseTime as default };

package/dist/es/parseTimeTest.js

@@ -0,0 +1,2 @@
+import './src/parseTimeTest.js';
+export { __exports as default } from './_virtual/parseTimeTest.js';

package/dist/es/src/parseTimeTest.js

@@ -0,0 +1,244 @@
+import dayjs$1 from 'dayjs';
+
+const dayjs = dayjs$1;
+const defaultFormat = "YYYY-MM-DD";
+function parseTime(config) {
+  const {
+    params,
+    format = defaultFormat,
+    type = "string",
+    fromKeys = [],
+    toKeys = [],
+    endType,
+  } = config;
+
+  // 获取最终结果
+  const getParseResult = parseByResult({ format, type });
+
+  // 如果传入的是一个字符串(就是单字段)
+  if (typeof params === "string" || typeof params === "number") {
+    // 1. 结果类型是一个日期对象
+    // 2. 如果结果类型是字符串，那么字符串转字符串可能的一个场景是：将一个日期格式的数据转成另外一种格式的日期
+    return getParseResult({
+      value: params,
+      endType: typeof endType === "string" ? endType : undefined,
+    });
+  } else {
+    // 浅拷贝一下
+    const newParams = Object.assign({}, params);
+
+    fromKeys.forEach((fromKey, index) => {
+      const toKey = toKeys[index];
+      const endTypeItem = Array.isArray(endType) ? endType[index] : endType;
+      // 1. 从一个键 转成 一个键
+      if (typeof fromKey === "string" && typeof toKey === "string") {
+        newParams[toKey] = getParseResult({
+          value: newParams[fromKey],
+          index,
+          endType: endTypeItem,
+        });
+        if (fromKey !== toKey) {
+          // 删除原有key
+          Reflect.deleteProperty(newParams, fromKey);
+        }
+      }
+      // 2. 从一个键 转成 两个键
+      if (typeof fromKey === "string" && typeof toKey === "object") {
+        const [toKey1, toKey2] = toKey;
+        // 初始定义转义类型 是否拼接一天的开始 一天的结束
+        let startEndType = "startOf";
+        let endEndType = "endOf";
+        if (Array.isArray(endTypeItem)) {
+          startEndType = endTypeItem[0];
+          endEndType = endTypeItem[1];
+        }
+        newParams[toKey1] = getParseResult({
+          value: newParams[fromKey],
+          index,
+          endType: startEndType,
+        });
+        newParams[toKey2] = getParseResult({
+          value: newParams[fromKey],
+          index,
+          endType: endEndType,
+        });
+        if (fromKey !== toKey1 && fromKey !== toKey2) {
+          Reflect.deleteProperty(newParams, fromKey);
+        }
+      }
+      // 3. 从两个键 转成 一个键
+      if (typeof fromKey === "object" && typeof toKey === "string") {
+        const [fromKey1, fromtKey2] = fromKey;
+        // 初始定义转义类型 是否拼接一天的开始 一天的结束
+        let startEndType = "startOf";
+        let endEndType = "endOf";
+        if (Array.isArray(endTypeItem)) {
+          startEndType = endTypeItem[0];
+          endEndType = endTypeItem[1];
+        }
+        newParams[toKey] = [
+          getParseResult({
+            value: newParams[fromKey1],
+            index,
+            endType: startEndType,
+          }),
+          getParseResult({
+            value: newParams[fromtKey2],
+            index,
+            endType: endEndType,
+          }),
+        ];
+        if (fromKey1 !== toKey) {
+          Reflect.deleteProperty(newParams, fromKey1);
+        }
+        if (fromtKey2 !== toKey) {
+          Reflect.deleteProperty(newParams, fromtKey2);
+        }
+      }
+      // 4. 从两个键 转成 两个键
+      if (typeof fromKey === "object" && typeof toKey === "object") {
+        const [fromKey1, fromtKey2] = fromKey;
+        const [toKey1, toKey2] = toKey;
+        // 初始定义转义类型 是否拼接一天的开始 一天的结束
+        let startEndType = undefined;
+        let endEndType = undefined;
+        if (Array.isArray(endTypeItem)) {
+          startEndType = endTypeItem[0];
+          endEndType = endTypeItem[1];
+        }
+        newParams[toKey1] = getParseResult({
+          value: newParams[fromKey1],
+          index,
+          endType: startEndType,
+        });
+        newParams[toKey2] = getParseResult({
+          value: newParams[fromtKey2],
+          index,
+          endType: endEndType,
+        });
+        if (fromKey1 !== toKey1) {
+          // 删除原有key
+          Reflect.deleteProperty(newParams, fromKey1);
+        }
+        if (fromtKey2 !== toKey2) {
+          // 删除原有key
+          Reflect.deleteProperty(newParams, fromtKey2);
+        }
+      }
+    });
+
+    return newParams;
+  }
+}
+
+function parseByResult(option) {
+  const { format = defaultFormat, type = "string" } = option;
+
+  return (option) => {
+    const { value, index = 0, endType } = option;
+    if (!value) {
+      return undefined;
+    }
+    const parseType = typeof type === "string" ? type : type[index];
+    const parseFormat = typeof format === "string" ? format : format[index];
+    const parseEndType = Array.isArray(endType) ? endType[0] : endType;
+    if (parseType === "string") {
+      const dayjsValue = dayjs.isDayjs(value) ? value : dayjs(value);
+      if (parseEndType === "startOf") {
+        return dayjsValue
+          .startOf("day")
+          .format(
+            parseFormat.length === 10 ? `${parseFormat} HH:mm:ss` : parseFormat
+          );
+      }
+      if (parseEndType === "endOf") {
+        return dayjsValue
+          .endOf("day")
+          .format(
+            parseFormat.length === 10 ? `${parseFormat} HH:mm:ss` : parseFormat
+          );
+      }
+      return dayjsValue.format(parseFormat);
+    } else {
+      if (parseEndType === "startOf") {
+        return dayjs(value).startOf("day");
+      }
+      if (parseEndType === "endOf") {
+        return dayjs(value).endOf("day");
+      }
+      return dayjs(value);
+    }
+  };
+}
+
+// 处理单字段
+// 时间戳处理
+// console.log(
+//   parseTime({
+//     params: Date.now(),
+//   })
+// );
+// 将日期格式字符串转换成dayjs
+// console.log(
+//   parseTime({
+//     params: "2023-09-22",
+//     type: "object",
+//   })
+// );
+// 添加一天的开始 结束
+// console.log(
+//   parseTime({
+//     params: "2023-09-22",
+//     endType: "startOf",
+//   })
+// );
+// console.log(
+//   parseTime({
+//     params: "2023-09-22",
+//     endType: "endOf",
+//   })
+// );
+
+// 多字段用例
+console.log(
+  parseTime({
+    params: { time: "2023-08-11" },
+    fromKeys: ["time"],
+    toKeys: ["resultTime"],
+    endType: "endOf",
+  })
+);
+console.log(
+  parseTime({
+    params: { time: "2023-08-11", time1: "2023-08-12" },
+    fromKeys: ["time", "time1"],
+    toKeys: ["resultTime", "resultTime2"],
+    endType: ["startOf", "endOf"],
+  })
+);
+console.log(
+  parseTime({
+    params: { time: "2023-08-11", time1: "2023-08-12" },
+    fromKeys: [["time", "time1"]],
+    toKeys: ["resultTime"],
+    type: "object",
+    endType: ["startOf", "endOf"],
+  })
+);
+console.log(
+  parseTime({
+    params: {
+      time: "2023-08-11",
+      time1: "2023-08-12",
+      time2: "2023-08-08",
+      time3: "2023-08-01",
+    },
+    fromKeys: [["time", "time1"], "time2", "time3"],
+    toKeys: ["resultTime", ["time2Start", "time2End"], "time3Result"],
+    // type: "object",
+    endType: [
+      ["endOf", "endOf"],
+      ["startOf", "startOf"],
+    ],
+  })
+);

package/dist/es/src/test.js

@@ -0,0 +1,71 @@
+import dayjs$1 from 'dayjs';
+
+function unescapeString(input) {
+  if (!input) {
+    return "";
+  }
+
+  const escapedChars = {
+    "&": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#039;": "'",
+  };
+
+  return input.replace(/&(amp|lt|gt|quot|#039);/g, (match) => {
+    return escapedChars[match] || match;
+  });
+}
+
+function dangerouslySetXss(input) {
+  if (!input) {
+    return "";
+  }
+  const escapedChars = {
+    "&lt;": "<",
+    "&gt;": ">",
+    "&nbsp;": " ",
+    "&amp;": "&",
+    "&quot;": '"',
+  };
+
+  return input.replace(/&(amp|lt|gt|quot|nbsp);/g, (match) => {
+    return escapedChars[match] || match;
+  });
+}
+
+function dangerouslySetXss1(input) {
+  if (!input) {
+    return "";
+  }
+  const escapedChars = {
+    lt: "<",
+    gt: ">",
+    nbsp: " ",
+    amp: "&",
+    quot: '"',
+  };
+
+  return input.replace(/&(amp|lt|gt|quot|nbsp);/gi, (match, t) => {
+    return escapedChars[t] || match;
+  });
+}
+
+console.log(unescapeString("&amp;&amp;&amp;啊你"));
+
+console.log(dangerouslySetXss("&amp;&amp;&amp;啊你"));
+
+console.log(dangerouslySetXss1("&amp;&amp;&amp;啊你"));
+console.log(unescapeString("1、aa&gt;80%\n2、&gt;&lt;\n3、ss&lt;80%"));
+console.log(dangerouslySetXss("1、aa&gt;80%\n2、&gt;&lt;\n3、ss&lt;80%"));
+console.log(dangerouslySetXss1("1、aa&gt;80%\n2、&gt;&lt;\n3、ss&lt;80%"));
+
+const dayjs = dayjs$1;
+
+const a = dayjs("2023-01-01 11:11").startOf("day");
+const formattedDate = a.format("YYYY-MM-DD HH:mm:ss");
+
+const b = dayjs("2023-01-01").endOf("day");
+const formattedDate1 = b.format("YYYY-MM-DD HH:mm:ss");
+console.log(formattedDate, formattedDate1);

package/dist/es/test.js

@@ -1,158 +1,2 @@
-function unescapeString(input) {
-  if (!input) {
-    return "";
-  }
-
-  const escapedChars = {
-    "&": "&",
-    "&lt;": "<",
-    "&gt;": ">",
-    "&quot;": '"',
-    "&#039;": "'",
-  };
-
-  return input.replace(/&(amp|lt|gt|quot|#039);/g, (match) => {
-    return escapedChars[match] || match;
-  });
-}
-
-function dangerouslySetXss(input) {
-  if (!input) {
-    return "";
-  }
-  const escapedChars = {
-    "&lt;": "<",
-    "&gt;": ">",
-    "&nbsp;": " ",
-    "&amp;": "&",
-    "&quot;": '"',
-  };
-
-  return input.replace(/&(amp|lt|gt|quot|nbsp);/g, (match) => {
-    return escapedChars[match] || match;
-  });
-}
-
-function dangerouslySetXss1(input) {
-  if (!input) {
-    return "";
-  }
-  const escapedChars = {
-    lt: "<",
-    gt: ">",
-    nbsp: " ",
-    amp: "&",
-    quot: '"',
-  };
-
-  return input.replace(/&(amp|lt|gt|quot|nbsp);/gi, (match, t) => {
-    return escapedChars[t] || match;
-  });
-}
-
-console.log(unescapeString("&amp;&amp;&amp;啊你"));
-
-console.log(dangerouslySetXss("&amp;&amp;&amp;啊你"));
-
-console.log(dangerouslySetXss1("&amp;&amp;&amp;啊你"));
-console.log(unescapeString("1、aa&gt;80%\n2、&gt;&lt;\n3、ss&lt;80%"));
-console.log(dangerouslySetXss("1、aa&gt;80%\n2、&gt;&lt;\n3、ss&lt;80%"));
-console.log(dangerouslySetXss1("1、aa&gt;80%\n2、&gt;&lt;\n3、ss&lt;80%"));
-
-// functions and constants
-// console.log("functions and constants");
-// print(math.round(math.e, 3)); // 2.718
-// print(math.atan2(3, -3) / math.pi); // 0.75
-// print(math.log(10000, 10)); // 4
-// print(math.sqrt(-4)); // 2i
-// print(
-//   math.pow(
-//     [
-//       [-1, 2],
-//       [3, 1],
-//     ],
-//     2
-//   )
-// ); // [[7, 0], [0, 7]]
-// print(math.derivative("x^2 + x", "x")); // 2 * x + 1
-// console.log();
-
-// // expressions
-// console.log("expressions");
-// print(math.evaluate("1.2 * (2 + 4.5)")); // 7.8
-// print(math.evaluate("12.7 cm to inch")); // 5 inch
-// print(math.evaluate("sin(45 deg) ^ 2")); // 0.5
-// print(math.evaluate("9 / 3 + 2i")); // 3 + 2i
-// print(math.evaluate("det([-1, 2; 3, 1])")); // -7
-// print(math.evaluate("NaN + '0.2'")); // -7
-// console.log();
-
-// // chained operations
-// console.log("chained operations");
-// const a = math.chain(3).add(4).multiply(2).done();
-// print(a); // 14
-// console.log();
-
-// // mixed use of different data types in functions
-// console.log("mixed use of data types");
-// print(math.add(4, [5, 6])); // number + Array, [9, 10]
-// print(math.multiply(math.unit("5 mm"), 3)); // Unit * number,  15 mm
-// print(math.subtract([2, 3, 4], 5)); // Array - number, [-3, -2, -1]
-// print(math.add(math.matrix([2, 3]), [4, 5])); // Matrix + Array, [6, 8]
-// console.log();
-
-// /**
-//  * Helper function to output a value in the console. Value will be formatted.
-//  * @param {*} value
-//  */
-// function print(value) {
-//   const precision = 14;
-//   console.log(math.format(value, precision));
-// }
-
-// const math = require("mathjs");
-// function print(value) {
-//   const precision = 14;
-//   console.log(math.format(value, precision));
-// }
-
-// console.log(performance.now());
-// console.log(math.add(0.1, 0.2));
-// console.log(performance.now());
-// console.log(performance.now());
-// console.log(0.1 + 0.2);
-// console.log(performance.now());
-// const BigNumber = require("bignumber.js");
-// console.log(performance.now());
-// const num1 = new BigNumber(0.1);
-// const num2 = new BigNumber(0.2);
-
-// const result = num1.plus(num2);
-
-// console.log(result.toString());
-
-// console.log(performance.now());
-
-// const Decimal = require("decimal.js");
-
-// const num1 = new Decimal("0.1");
-
-// console.log(num1.add(0.21).toNumber(), typeof num1.add(0.21).toNumber());
-
-// console.log(num1.sub(0.21).toNumber(), typeof num1.sub(0.21).toNumber());
-
-// console.log(num1.mul(0.21).toNumber(), typeof num1.mul(0.21).toNumber());
-// Decimal.set({ precision: 5 });
-// console.log(
-//   new Decimal(1).div(1.1).toNumber(),
-//   typeof new Decimal(1).div(1.1).toNumber()
-// );
-// console.log(
-//   new Decimal(1).dividedBy(1.1).toNumber(),
-//   typeof new Decimal(1).dividedBy(1.1).toNumber()
-// );
-
-// console.log(
-//   Number(new Decimal(1.1).toFixed(2)),
-//   typeof Number(new Decimal(1.1).toFixed(2)).toFixed(2)
-// );
+import './src/test.js';
+export { __exports as default } from './_virtual/test.js';

package/dist/index.d.ts

@@ -10,4 +10,5 @@ export { divide, exactRound, formatUnit, minus, plus, times } from './es/math.js
 export { validatePassword } from './es/passwordValidate.js';
 export { emailValidate, idCardValidate, morePhoneValidate, phoneValidate, strLenValidate } from './es/validate.js';
 export { batchDownloadFiles, createDeleteFileLink, createDownloadLink, createOriginalLink, createThumbnailLink, createUploadFileLink, downloadFile, exportBolb, previewFile } from './es/file.js';
+export { default as parseTime } from './es/parseTime.js';
 export { EMITTER_CCP_KEY, EMITTER_PCC_KEY, EMITTER_TYPE } from './es/constants.js';

package/dist/index.js

@@ -10,4 +10,5 @@ export { divide, exactRound, formatUnit, minus, plus, times } from './es/math.js
 export { validatePassword } from './es/passwordValidate.js';
 export { emailValidate, idCardValidate, morePhoneValidate, phoneValidate, strLenValidate } from './es/validate.js';
 export { batchDownloadFiles, createDeleteFileLink, createDownloadLink, createOriginalLink, createThumbnailLink, createUploadFileLink, downloadFile, exportBolb, previewFile } from './es/file.js';
+export { default as parseTime } from './es/parseTime.js';
 export { EMITTER_CCP_KEY, EMITTER_PCC_KEY, EMITTER_TYPE } from './es/constants.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zmdms-utils",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "description": "",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -15,7 +15,8 @@
   "peerDependencies": {
     "axios": "^1.4.0",
     "crypto-js": "^4.1.1",
-    "qiankun": "^2.10.8"
+    "qiankun": "^2.10.8",
+    "dayjs": "^1.11.7"
   },
   "dependencies": {
     "decimal.js": "^10.4.3",
@@ -28,6 +29,7 @@
     "@types/crypto-js": "^4.1.1",
     "axios": "^1.4.0",
     "crypto-js": "^4.1.1",
+    "dayjs": "^1.11.10",
     "qiankun": "^2.10.8",
     "rimraf": "^4.4.1",
     "rollup": "^3.20.2",

package/src/index.ts

@@ -39,6 +39,10 @@ export {
   createUploadFileLink,
   createDeleteFileLink,
 } from "./file";
+/**
+ * 时间处理函数
+ */
+export { default as parseTime } from "./parseTime";
 
 /**
  * 常量相关

package/src/parseTime.ts

@@ -0,0 +1,210 @@
+import dayjs from "dayjs";
+
+const defaultFormat = "YYYY-MM-DD";
+
+type IType = "string" | "object";
+// 传入要转换成当天的第一秒 还是当天的最后一秒
+type IEndType = "startOf" | "endOf";
+interface IConfig {
+  // 需要转换的数据
+  params: string | number | object;
+  // 格式
+  format?: string | string[];
+  // 结果类型
+  type?: IType | IType[];
+  // 转换前的字段
+  fromKeys?: Array<string | string[]>;
+  // 转换后的字段
+  toKeys?: Array<string | string[]>;
+  // 末尾是要接 今日开始 今日结束 无
+  endType?: Array<IEndType | IEndType[]>;
+}
+/**
+ * 解析时间
+ * 可能转换的结果
+ * 日期对象转字符串
+ * Dayjs => "20xx-xx-xx"
+ * { key: Dayjs } => { key: "20xx-xx-xx" }
+ * { mergeKey: [Dayjs, Dayjs] } => { key1: "20xx-xx-xx", key2: "20xx-xx-xx" }
+ * 字符串转日期对象
+ * "20xx-xx-xx" => Dayjs
+ * { key: "20xx-xx-xx" } => { key: Dayjs }
+ * { key1: "20xx-xx-xx", key1: "20xx-xx-xx" } => { mergeKey: [Dayjs, Dayjs] }
+ */
+export default function parseTime(config: IConfig) {
+  const {
+    params,
+    format = defaultFormat,
+    type = "string",
+    fromKeys = [],
+    toKeys = [],
+    endType,
+  } = config;
+
+  // 获取最终结果
+  const getParseResult = parseByResult({ format, type });
+
+  // 如果传入的是一个字符串(就是单字段)
+  if (typeof params === "string" || typeof params === "number") {
+    // 1. 结果类型是一个日期对象
+    // 2. 如果结果类型是字符串，那么字符串转字符串可能的一个场景是：将一个日期格式的数据转成另外一种格式的日期
+    return getParseResult({
+      value: params,
+      endType: typeof endType === "string" ? endType : undefined,
+    });
+  } else {
+    // 浅拷贝一下
+    const newParams: any = Object.assign({}, params);
+
+    fromKeys.forEach((fromKey, index) => {
+      const toKey = toKeys[index];
+      const endTypeItem = Array.isArray(endType) ? endType[index] : endType;
+      // 1. 从一个键 转成 一个键
+      if (typeof fromKey === "string" && typeof toKey === "string") {
+        newParams[toKey] = getParseResult({
+          value: newParams[fromKey],
+          index,
+          endType: endTypeItem,
+        });
+        if (fromKey !== toKey) {
+          // 删除原有key
+          Reflect.deleteProperty(newParams, fromKey);
+        }
+      }
+      // 2. 从一个键 转成 两个键
+      if (typeof fromKey === "string" && typeof toKey === "object") {
+        const [toKey1, toKey2] = toKey;
+        // 初始定义转义类型 是否拼接一天的开始 一天的结束
+        let startEndType: IEndType | undefined = "startOf";
+        let endEndType: IEndType | undefined = "endOf";
+        if (Array.isArray(endTypeItem)) {
+          startEndType = endTypeItem[0];
+          endEndType = endTypeItem[1];
+        }
+        newParams[toKey1] = getParseResult({
+          value: newParams[fromKey],
+          index,
+          endType: startEndType,
+        });
+        newParams[toKey2] = getParseResult({
+          value: newParams[fromKey],
+          index,
+          endType: endEndType,
+        });
+        if (fromKey !== toKey1 && fromKey !== toKey2) {
+          Reflect.deleteProperty(newParams, fromKey);
+        }
+      }
+      // 3. 从两个键 转成 一个键
+      if (typeof fromKey === "object" && typeof toKey === "string") {
+        const [fromKey1, fromtKey2] = fromKey;
+        // 初始定义转义类型 是否拼接一天的开始 一天的结束
+        let startEndType: IEndType | undefined = "startOf";
+        let endEndType: IEndType | undefined = "endOf";
+        if (Array.isArray(endTypeItem)) {
+          startEndType = endTypeItem[0];
+          endEndType = endTypeItem[1];
+        }
+        newParams[toKey] = [
+          getParseResult({
+            value: newParams[fromKey1],
+            index,
+            endType: startEndType,
+          }),
+          getParseResult({
+            value: newParams[fromtKey2],
+            index,
+            endType: endEndType,
+          }),
+        ];
+        if (fromKey1 !== toKey) {
+          Reflect.deleteProperty(newParams, fromKey1);
+        }
+        if (fromtKey2 !== toKey) {
+          Reflect.deleteProperty(newParams, fromtKey2);
+        }
+      }
+      // 4. 从两个键 转成 两个键
+      if (typeof fromKey === "object" && typeof toKey === "object") {
+        const [fromKey1, fromtKey2] = fromKey;
+        const [toKey1, toKey2] = toKey;
+        // 初始定义转义类型 是否拼接一天的开始 一天的结束
+        let startEndType: IEndType | undefined = undefined;
+        let endEndType: IEndType | undefined = undefined;
+        if (Array.isArray(endTypeItem)) {
+          startEndType = endTypeItem[0];
+          endEndType = endTypeItem[1];
+        }
+        newParams[toKey1] = getParseResult({
+          value: newParams[fromKey1],
+          index,
+          endType: startEndType,
+        });
+        newParams[toKey2] = getParseResult({
+          value: newParams[fromtKey2],
+          index,
+          endType: endEndType,
+        });
+        if (fromKey1 !== toKey1) {
+          // 删除原有key
+          Reflect.deleteProperty(newParams, fromKey1);
+        }
+        if (fromtKey2 !== toKey2) {
+          // 删除原有key
+          Reflect.deleteProperty(newParams, fromtKey2);
+        }
+      }
+    });
+
+    return newParams;
+  }
+}
+
+interface IProps {
+  format?: string | string[];
+  type?: IType | IType[];
+}
+interface IResultProps {
+  value?: any;
+  index?: number;
+  endType?: IEndType | IEndType[];
+}
+function parseByResult(option: IProps) {
+  const { format = defaultFormat, type = "string" } = option;
+
+  return (option: IResultProps) => {
+    const { value, index = 0, endType } = option;
+    if (!value) {
+      return undefined;
+    }
+    const parseType = typeof type === "string" ? type : type[index];
+    const parseFormat = typeof format === "string" ? format : format[index];
+    const parseEndType = Array.isArray(endType) ? endType[0] : endType;
+    if (parseType === "string") {
+      const dayjsValue = dayjs.isDayjs(value) ? value : dayjs(value);
+      if (parseEndType === "startOf") {
+        return dayjsValue
+          .startOf("day")
+          .format(
+            parseFormat.length === 10 ? `${parseFormat} HH:mm:ss` : parseFormat
+          );
+      }
+      if (parseEndType === "endOf") {
+        return dayjsValue
+          .endOf("day")
+          .format(
+            parseFormat.length === 10 ? `${parseFormat} HH:mm:ss` : parseFormat
+          );
+      }
+      return dayjsValue.format(parseFormat);
+    } else {
+      if (parseEndType === "startOf") {
+        return dayjs(value).startOf("day");
+      }
+      if (parseEndType === "endOf") {
+        return dayjs(value).endOf("day");
+      }
+      return dayjs(value);
+    }
+  };
+}

package/src/parseTimeTest.js

@@ -0,0 +1,242 @@
+const dayjs = require("dayjs");
+const defaultFormat = "YYYY-MM-DD";
+function parseTime(config) {
+  const {
+    params,
+    format = defaultFormat,
+    type = "string",
+    fromKeys = [],
+    toKeys = [],
+    endType,
+  } = config;
+
+  // 获取最终结果
+  const getParseResult = parseByResult({ format, type });
+
+  // 如果传入的是一个字符串(就是单字段)
+  if (typeof params === "string" || typeof params === "number") {
+    // 1. 结果类型是一个日期对象
+    // 2. 如果结果类型是字符串，那么字符串转字符串可能的一个场景是：将一个日期格式的数据转成另外一种格式的日期
+    return getParseResult({
+      value: params,
+      endType: typeof endType === "string" ? endType : undefined,
+    });
+  } else {
+    // 浅拷贝一下
+    const newParams = Object.assign({}, params);
+
+    fromKeys.forEach((fromKey, index) => {
+      const toKey = toKeys[index];
+      const endTypeItem = Array.isArray(endType) ? endType[index] : endType;
+      // 1. 从一个键 转成 一个键
+      if (typeof fromKey === "string" && typeof toKey === "string") {
+        newParams[toKey] = getParseResult({
+          value: newParams[fromKey],
+          index,
+          endType: endTypeItem,
+        });
+        if (fromKey !== toKey) {
+          // 删除原有key
+          Reflect.deleteProperty(newParams, fromKey);
+        }
+      }
+      // 2. 从一个键 转成 两个键
+      if (typeof fromKey === "string" && typeof toKey === "object") {
+        const [toKey1, toKey2] = toKey;
+        // 初始定义转义类型 是否拼接一天的开始 一天的结束
+        let startEndType = "startOf";
+        let endEndType = "endOf";
+        if (Array.isArray(endTypeItem)) {
+          startEndType = endTypeItem[0];
+          endEndType = endTypeItem[1];
+        }
+        newParams[toKey1] = getParseResult({
+          value: newParams[fromKey],
+          index,
+          endType: startEndType,
+        });
+        newParams[toKey2] = getParseResult({
+          value: newParams[fromKey],
+          index,
+          endType: endEndType,
+        });
+        if (fromKey !== toKey1 && fromKey !== toKey2) {
+          Reflect.deleteProperty(newParams, fromKey);
+        }
+      }
+      // 3. 从两个键 转成 一个键
+      if (typeof fromKey === "object" && typeof toKey === "string") {
+        const [fromKey1, fromtKey2] = fromKey;
+        // 初始定义转义类型 是否拼接一天的开始 一天的结束
+        let startEndType = "startOf";
+        let endEndType = "endOf";
+        if (Array.isArray(endTypeItem)) {
+          startEndType = endTypeItem[0];
+          endEndType = endTypeItem[1];
+        }
+        newParams[toKey] = [
+          getParseResult({
+            value: newParams[fromKey1],
+            index,
+            endType: startEndType,
+          }),
+          getParseResult({
+            value: newParams[fromtKey2],
+            index,
+            endType: endEndType,
+          }),
+        ];
+        if (fromKey1 !== toKey) {
+          Reflect.deleteProperty(newParams, fromKey1);
+        }
+        if (fromtKey2 !== toKey) {
+          Reflect.deleteProperty(newParams, fromtKey2);
+        }
+      }
+      // 4. 从两个键 转成 两个键
+      if (typeof fromKey === "object" && typeof toKey === "object") {
+        const [fromKey1, fromtKey2] = fromKey;
+        const [toKey1, toKey2] = toKey;
+        // 初始定义转义类型 是否拼接一天的开始 一天的结束
+        let startEndType = undefined;
+        let endEndType = undefined;
+        if (Array.isArray(endTypeItem)) {
+          startEndType = endTypeItem[0];
+          endEndType = endTypeItem[1];
+        }
+        newParams[toKey1] = getParseResult({
+          value: newParams[fromKey1],
+          index,
+          endType: startEndType,
+        });
+        newParams[toKey2] = getParseResult({
+          value: newParams[fromtKey2],
+          index,
+          endType: endEndType,
+        });
+        if (fromKey1 !== toKey1) {
+          // 删除原有key
+          Reflect.deleteProperty(newParams, fromKey1);
+        }
+        if (fromtKey2 !== toKey2) {
+          // 删除原有key
+          Reflect.deleteProperty(newParams, fromtKey2);
+        }
+      }
+    });
+
+    return newParams;
+  }
+}
+
+function parseByResult(option) {
+  const { format = defaultFormat, type = "string" } = option;
+
+  return (option) => {
+    const { value, index = 0, endType } = option;
+    if (!value) {
+      return undefined;
+    }
+    const parseType = typeof type === "string" ? type : type[index];
+    const parseFormat = typeof format === "string" ? format : format[index];
+    const parseEndType = Array.isArray(endType) ? endType[0] : endType;
+    if (parseType === "string") {
+      const dayjsValue = dayjs.isDayjs(value) ? value : dayjs(value);
+      if (parseEndType === "startOf") {
+        return dayjsValue
+          .startOf("day")
+          .format(
+            parseFormat.length === 10 ? `${parseFormat} HH:mm:ss` : parseFormat
+          );
+      }
+      if (parseEndType === "endOf") {
+        return dayjsValue
+          .endOf("day")
+          .format(
+            parseFormat.length === 10 ? `${parseFormat} HH:mm:ss` : parseFormat
+          );
+      }
+      return dayjsValue.format(parseFormat);
+    } else {
+      if (parseEndType === "startOf") {
+        return dayjs(value).startOf("day");
+      }
+      if (parseEndType === "endOf") {
+        return dayjs(value).endOf("day");
+      }
+      return dayjs(value);
+    }
+  };
+}
+
+// 处理单字段
+// 时间戳处理
+// console.log(
+//   parseTime({
+//     params: Date.now(),
+//   })
+// );
+// 将日期格式字符串转换成dayjs
+// console.log(
+//   parseTime({
+//     params: "2023-09-22",
+//     type: "object",
+//   })
+// );
+// 添加一天的开始 结束
+// console.log(
+//   parseTime({
+//     params: "2023-09-22",
+//     endType: "startOf",
+//   })
+// );
+// console.log(
+//   parseTime({
+//     params: "2023-09-22",
+//     endType: "endOf",
+//   })
+// );
+
+// 多字段用例
+console.log(
+  parseTime({
+    params: { time: "2023-08-11" },
+    fromKeys: ["time"],
+    toKeys: ["resultTime"],
+    endType: "endOf",
+  })
+);
+console.log(
+  parseTime({
+    params: { time: "2023-08-11", time1: "2023-08-12" },
+    fromKeys: ["time", "time1"],
+    toKeys: ["resultTime", "resultTime2"],
+    endType: ["startOf", "endOf"],
+  })
+);
+console.log(
+  parseTime({
+    params: { time: "2023-08-11", time1: "2023-08-12" },
+    fromKeys: [["time", "time1"]],
+    toKeys: ["resultTime"],
+    type: "object",
+    endType: ["startOf", "endOf"],
+  })
+);
+console.log(
+  parseTime({
+    params: {
+      time: "2023-08-11",
+      time1: "2023-08-12",
+      time2: "2023-08-08",
+      time3: "2023-08-01",
+    },
+    fromKeys: [["time", "time1"], "time2", "time3"],
+    toKeys: ["resultTime", ["time2Start", "time2End"], "time3Result"],
+    // type: "object",
+    endType: [
+      ["endOf", "endOf"],
+      ["startOf", "startOf"],
+    ],
+  })
+);

package/src/test.js

@@ -59,6 +59,15 @@ console.log(unescapeString("1、aa>80%\n2、><\n3、ss<80%"));
 console.log(dangerouslySetXss("1、aa>80%\n2、><\n3、ss<80%"));
 console.log(dangerouslySetXss1("1、aa>80%\n2、><\n3、ss<80%"));
 
+const dayjs = require("dayjs");
+
+const a = dayjs("2023-01-01 11:11").startOf("day");
+const formattedDate = a.format("YYYY-MM-DD HH:mm:ss");
+
+const b = dayjs("2023-01-01").endOf("day");
+const formattedDate1 = b.format("YYYY-MM-DD HH:mm:ss");
+console.log(formattedDate, formattedDate1);
+
 // functions and constants
 // console.log("functions and constants");
 // print(math.round(math.e, 3)); // 2.718