@cloudcome/utils-core 1.19.1 → 1.20.0

package/dist/time.cjs

@@ -1,82 +1,159 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const _const = require("./const.cjs");
-const type = require("./type.cjs");
-const rules = [
-  ["years", _const.DATE_YEAR_MS],
-  ["months", _const.DATE_MONTH_MS],
-  ["days", _const.DATE_DAY_MS],
-  ["hours", _const.DATE_HOUR_MS],
-  ["minutes", _const.DATE_MINUTE_MS],
-  ["seconds", _const.DATE_SECOND_MS]
+const require_type = require("./type.cjs");
+const require_date = require("./date.cjs");
+//#region src/time/from.ts
+/**
+* 时间转换规则数组
+* @type {Array<[RegExp, (match: RegExpMatchArray) => number]>}
+* @property {RegExp} 0 - 匹配时间单位正则表达式
+* @property {function} 1 - 将匹配结果转换为毫秒数的函数
+*/
+var rules = [
+	["years", require_date.DATE_YEAR_MS],
+	["months", require_date.DATE_MONTH_MS],
+	["days", require_date.DATE_DAY_MS],
+	["hours", require_date.DATE_HOUR_MS],
+	["minutes", require_date.DATE_MINUTE_MS],
+	["seconds", require_date.DATE_SECOND_MS]
 ];
+/**
+* 将时间持续时间字符串或对象转换为毫秒数
+*
+* @param duration - 可以是时间持续时间字符串（如 '1d2h'）或 TimeDuration 对象
+* @returns 计算得到的总毫秒数
+*/
 function timeFrom(duration) {
-  const td = type.isString(duration) ? timeParse(duration) : duration;
-  return rules.reduce((acc, [key, time]) => acc + (td[key] || 0) * time, 0);
+	const td = require_type.isString(duration) ? timeParse(duration) : duration;
+	return rules.reduce((acc, [key, time]) => acc + (td[key] || 0) * time, 0);
 }
-const durationMatchRules = [
-  [/(\d+)y/i, "years"],
-  [/(\d+)M/, "months"],
-  [/(\d+)d/i, "days"],
-  [/(\d+)h/i, "hours"],
-  [/(\d+)m/, "minutes"],
-  [/(\d+)s/, "seconds"]
+var durationMatchRules = [
+	[/(\d+)y/i, "years"],
+	[/(\d+)M/, "months"],
+	[/(\d+)d/i, "days"],
+	[/(\d+)h/i, "hours"],
+	[/(\d+)m/, "minutes"],
+	[/(\d+)s/, "seconds"]
 ];
+/**
+* 将时长字符串解析为时间对象
+* @param duration - 时长字符串（例如 "1h30m"）
+* @returns 包含解析后时间单位的对象（小时、分钟等）
+*/
 function timeParse(duration) {
-  const result = {};
-  for (const [regex, key] of durationMatchRules) {
-    const match = duration.match(regex);
-    if (match) result[key] = Number(match[1]);
-    else result[key] = 0;
-  }
-  return result;
+	const result = {};
+	for (const [regex, key] of durationMatchRules) {
+		const match = duration.match(regex);
+		if (match) result[key] = Number(match[1]);
+		else result[key] = 0;
+	}
+	return result;
 }
+//#endregion
+//#region src/time/to.ts
+/**
+* 解析时间毫秒数为绝对时间对象
+* @param timeMs 时间毫秒数
+* @param maxPoint 最大时间单位（决定分解的起始单位）
+* @returns 包含时间单位分解结果的对象
+* @example
+* ```typescript
+* // 默认以天为最大单位分解
+* timeInDay(123456789);
+* // { days: 1, hours: 10, minutes: 17, seconds: 36, milliseconds: 789 }
+*
+* // 指定最大单位为分钟，分解到分钟及以下单位
+* timeInMinute(123456789);
+* // { days: 0, hours: 0, minutes: 2057, seconds: 36, milliseconds: 789 }
+* ```
+*/
 function _timeAbsolute(timeMs, maxPoint) {
-  const minPoint = "S";
-  const defines = [
-    ["D", "days", _const.DATE_DAY_MS],
-    ["h", "hours", _const.DATE_HOUR_MS],
-    ["m", "minutes", _const.DATE_MINUTE_MS],
-    ["s", "seconds", _const.DATE_SECOND_MS],
-    ["S", "milliseconds", 1]
-  ];
-  const minIndex = defines.findIndex((item) => item[0] === maxPoint);
-  const maxIndex = defines.findIndex((item) => item[0] === minPoint);
-  let timeMsFinal = timeMs;
-  const dao = {
-    years: 0,
-    months: 0,
-    days: 0,
-    hours: 0,
-    minutes: 0,
-    seconds: 0,
-    milliseconds: 0
-  };
-  for (let i = minIndex; i <= maxIndex; i++) {
-    const mode = defines[i];
-    const base = mode[2];
-    const value = Math.floor(timeMsFinal / base);
-    timeMsFinal = timeMsFinal - value * base;
-    dao[mode[1]] = value;
-  }
-  return dao;
+	const minPoint = "S";
+	const defines = [
+		[
+			"D",
+			"days",
+			require_date.DATE_DAY_MS
+		],
+		[
+			"h",
+			"hours",
+			require_date.DATE_HOUR_MS
+		],
+		[
+			"m",
+			"minutes",
+			require_date.DATE_MINUTE_MS
+		],
+		[
+			"s",
+			"seconds",
+			require_date.DATE_SECOND_MS
+		],
+		[
+			"S",
+			"milliseconds",
+			1
+		]
+	];
+	const minIndex = defines.findIndex((item) => item[0] === maxPoint);
+	const maxIndex = defines.findIndex((item) => item[0] === minPoint);
+	let timeMsFinal = timeMs;
+	const dao = {
+		years: 0,
+		months: 0,
+		days: 0,
+		hours: 0,
+		minutes: 0,
+		seconds: 0,
+		milliseconds: 0
+	};
+	for (let i = minIndex; i <= maxIndex; i++) {
+		const mode = defines[i];
+		const base = mode[2];
+		const value = Math.floor(timeMsFinal / base);
+		timeMsFinal = timeMsFinal - value * base;
+		dao[mode[1]] = value;
+	}
+	return dao;
 }
+/**
+* 将时间毫秒数解析为以天为最大单位的绝对时间对象
+* @param timeMs 时间毫秒数
+* @returns 包含天/小时/分钟/秒/毫秒分解结果的对象
+*/
 function timeToDays(timeMs) {
-  return _timeAbsolute(timeMs, "D");
+	return _timeAbsolute(timeMs, "D");
 }
+/**
+* 将时间毫秒数解析为以小时为最大单位的绝对时间对象
+* @param timeMs 时间毫秒数
+* @returns 包含小时/分钟/秒/毫秒分解结果的对象
+*/
 function timeToHours(timeMs) {
-  return _timeAbsolute(timeMs, "h");
+	return _timeAbsolute(timeMs, "h");
 }
+/**
+* 将时间毫秒数解析为以分钟为最大单位的绝对时间对象
+* @param timeMs 时间毫秒数
+* @returns 包含分钟/秒/毫秒分解结果的对象
+*/
 function timeToMinutes(timeMs) {
-  return _timeAbsolute(timeMs, "m");
+	return _timeAbsolute(timeMs, "m");
 }
+/**
+* 将时间毫秒数解析为以秒为最大单位的绝对时间对象
+* @param timeMs 时间毫秒数
+* @returns 包含秒/毫秒分解结果的对象
+*/
 function timeToSeconds(timeMs) {
-  return _timeAbsolute(timeMs, "s");
+	return _timeAbsolute(timeMs, "s");
 }
+//#endregion
 exports.timeFrom = timeFrom;
 exports.timeParse = timeParse;
 exports.timeToDays = timeToDays;
 exports.timeToHours = timeToHours;
 exports.timeToMinutes = timeToMinutes;
 exports.timeToSeconds = timeToSeconds;
-//# sourceMappingURL=time.cjs.map
+
+//# sourceMappingURL=time.cjs.map

package/dist/time.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"time.cjs","sources":["../src/time/from.ts","../src/time/to.ts"],"sourcesContent":["// @rer https://day.js.org/docs/en/durations/creating\n\nimport { DATE_DAY_MS, DATE_HOUR_MS, DATE_MINUTE_MS, DATE_MONTH_MS, DATE_SECOND_MS, DATE_YEAR_MS } from '@/date';\nimport { isString } from '@/type';\nimport type { TimeDuration } from './to';\n\n/**\n * 时间转换规则数组\n * @type {Array<[RegExp, (match: RegExpMatchArray) => number]>}\n * @property {RegExp} 0 - 匹配时间单位正则表达式\n * @property {function} 1 - 将匹配结果转换为毫秒数的函数\n */\nconst rules: [key: keyof TimeDuration, time: number][] = [\n  ['years', DATE_YEAR_MS],\n  ['months', DATE_MONTH_MS],\n  ['days', DATE_DAY_MS],\n  ['hours', DATE_HOUR_MS],\n  ['minutes', DATE_MINUTE_MS],\n  ['seconds', DATE_SECOND_MS],\n];\n\n/**\n * 将时间持续时间字符串或对象转换为毫秒数\n *\n * @param duration - 可以是时间持续时间字符串（如 '1d2h'）或 TimeDuration 对象\n * @returns 计算得到的总毫秒数\n */\nexport function timeFrom(duration: string | TimeDuration) {\n  const td = isString(duration) ? timeParse(duration) : duration;\n  return rules.reduce((acc, [key, time]) => acc + (td[key] || 0) * time, 0);\n}\n\nconst durationMatchRules: [RegExp, key: keyof TimeDuration][] = [\n  [/(\\d+)y/i, 'years'],\n  [/(\\d+)M/, 'months'],\n  [/(\\d+)d/i, 'days'],\n  [/(\\d+)h/i, 'hours'],\n  [/(\\d+)m/, 'minutes'],\n  [/(\\d+)s/, 'seconds'],\n];\n\n/**\n * 将时长字符串解析为时间对象\n * @param duration - 时长字符串（例如 \"1h30m\"）\n * @returns 包含解析后时间单位的对象（小时、分钟等）\n */\nexport function timeParse(duration: string) {\n  const result = {} as TimeDuration;\n\n  for (const [regex, key] of durationMatchRules) {\n    const match = duration.match(regex);\n    if (match) result[key] = Number(match[1]);\n    else result[key] = 0;\n  }\n\n  return result;\n}\n","import { DATE_DAY_MS, DATE_HOUR_MS, DATE_MINUTE_MS, DATE_SECOND_MS } from '../date';\n\nexport type TimeDuration = {\n  years: number;\n  months: number;\n  /** 天数 */\n  days: number;\n  /** 小时数 */\n  hours: number;\n  /** 分钟数 */\n  minutes: number;\n  /** 秒数 */\n  seconds: number;\n  /** 毫秒数 */\n  milliseconds: number;\n};\n\ntype _TTimeParsePoint = 'D' | 'h' | 'm' | 's' | 'S';\n\n/**\n * 解析时间毫秒数为绝对时间对象\n * @param timeMs 时间毫秒数\n * @param maxPoint 最大时间单位（决定分解的起始单位）\n * @returns 包含时间单位分解结果的对象\n * @example\n * ```typescript\n * // 默认以天为最大单位分解\n * timeInDay(123456789);\n * // { days: 1, hours: 10, minutes: 17, seconds: 36, milliseconds: 789 }\n *\n * // 指定最大单位为分钟，分解到分钟及以下单位\n * timeInMinute(123456789);\n * // { days: 0, hours: 0, minutes: 2057, seconds: 36, milliseconds: 789 }\n * ```\n */\nfunction _timeAbsolute(timeMs: number, maxPoint: _TTimeParsePoint): TimeDuration {\n  const minPoint: _TTimeParsePoint = 'S';\n\n  const defines: [point: _TTimeParsePoint, key: keyof TimeDuration, base: number][] = [\n    ['D', 'days', DATE_DAY_MS],\n    ['h', 'hours', DATE_HOUR_MS],\n    ['m', 'minutes', DATE_MINUTE_MS],\n    ['s', 'seconds', DATE_SECOND_MS],\n    ['S', 'milliseconds', 1],\n  ] as const;\n\n  const minIndex = defines.findIndex((item) => item[0] === maxPoint);\n  const maxIndex = defines.findIndex((item) => item[0] === minPoint);\n\n  let timeMsFinal = timeMs;\n  const dao: TimeDuration = {\n    years: 0,\n    months: 0,\n    days: 0,\n    hours: 0,\n    minutes: 0,\n    seconds: 0,\n    milliseconds: 0,\n  };\n\n  for (let i = minIndex; i <= maxIndex; i++) {\n    const mode = defines[i];\n    const base = mode[2];\n    const value = Math.floor(timeMsFinal / base);\n    timeMsFinal = timeMsFinal - value * base;\n    dao[mode[1]] = value;\n  }\n\n  return dao;\n}\n\n/**\n * 将时间毫秒数解析为以天为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含天/小时/分钟/秒/毫秒分解结果的对象\n */\nexport function timeToDays(timeMs: number) {\n  return _timeAbsolute(timeMs, 'D');\n}\n\n/**\n * 将时间毫秒数解析为以小时为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含小时/分钟/秒/毫秒分解结果的对象\n */\nexport function timeToHours(timeMs: number) {\n  return _timeAbsolute(timeMs, 'h');\n}\n\n/**\n * 将时间毫秒数解析为以分钟为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含分钟/秒/毫秒分解结果的对象\n */\nexport function timeToMinutes(timeMs: number) {\n  return _timeAbsolute(timeMs, 'm');\n}\n\n/**\n * 将时间毫秒数解析为以秒为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含秒/毫秒分解结果的对象\n */\nexport function timeToSeconds(timeMs: number) {\n  return _timeAbsolute(timeMs, 's');\n}\n"],"names":["DATE_YEAR_MS","DATE_MONTH_MS","DATE_DAY_MS","DATE_HOUR_MS","DATE_MINUTE_MS","DATE_SECOND_MS","isString"],"mappings":";;;;AAYA,MAAM,QAAmD;AAAA,EACvD,CAAC,SAASA,OAAAA,YAAY;AAAA,EACtB,CAAC,UAAUC,OAAAA,aAAa;AAAA,EACxB,CAAC,QAAQC,OAAAA,WAAW;AAAA,EACpB,CAAC,SAASC,OAAAA,YAAY;AAAA,EACtB,CAAC,WAAWC,OAAAA,cAAc;AAAA,EAC1B,CAAC,WAAWC,OAAc,cAAA;AAC5B;AAQO,SAAS,SAAS,UAAiC;AACxD,QAAM,KAAKC,KAAAA,SAAS,QAAQ,IAAI,UAAU,QAAQ,IAAI;AACtD,SAAO,MAAM,OAAO,CAAC,KAAK,CAAC,KAAK,IAAI,MAAM,OAAO,GAAG,GAAG,KAAK,KAAK,MAAM,CAAC;AAC1E;AAEA,MAAM,qBAA0D;AAAA,EAC9D,CAAC,WAAW,OAAO;AAAA,EACnB,CAAC,UAAU,QAAQ;AAAA,EACnB,CAAC,WAAW,MAAM;AAAA,EAClB,CAAC,WAAW,OAAO;AAAA,EACnB,CAAC,UAAU,SAAS;AAAA,EACpB,CAAC,UAAU,SAAS;AACtB;AAOO,SAAS,UAAU,UAAkB;AAC1C,QAAM,SAAS,CAAC;AAEhB,aAAW,CAAC,OAAO,GAAG,KAAK,oBAAoB;AACvC,UAAA,QAAQ,SAAS,MAAM,KAAK;AAClC,QAAI,MAAc,QAAA,GAAG,IAAI,OAAO,MAAM,CAAC,CAAC;AAAA,QACnC,QAAO,GAAG,IAAI;AAAA,EAAA;AAGd,SAAA;AACT;ACrBA,SAAS,cAAc,QAAgB,UAA0C;AAC/E,QAAM,WAA6B;AAEnC,QAAM,UAA8E;AAAA,IAClF,CAAC,KAAK,QAAQJ,kBAAW;AAAA,IACzB,CAAC,KAAK,SAASC,mBAAY;AAAA,IAC3B,CAAC,KAAK,WAAWC,qBAAc;AAAA,IAC/B,CAAC,KAAK,WAAWC,qBAAc;AAAA,IAC/B,CAAC,KAAK,gBAAgB,CAAC;AAAA,EACzB;AAEM,QAAA,WAAW,QAAQ,UAAU,CAAC,SAAS,KAAK,CAAC,MAAM,QAAQ;AAC3D,QAAA,WAAW,QAAQ,UAAU,CAAC,SAAS,KAAK,CAAC,MAAM,QAAQ;AAEjE,MAAI,cAAc;AAClB,QAAM,MAAoB;AAAA,IACxB,OAAO;AAAA,IACP,QAAQ;AAAA,IACR,MAAM;AAAA,IACN,OAAO;AAAA,IACP,SAAS;AAAA,IACT,SAAS;AAAA,IACT,cAAc;AAAA,EAChB;AAEA,WAAS,IAAI,UAAU,KAAK,UAAU,KAAK;AACnC,UAAA,OAAO,QAAQ,CAAC;AAChB,UAAA,OAAO,KAAK,CAAC;AACnB,UAAM,QAAQ,KAAK,MAAM,cAAc,IAAI;AAC3C,kBAAc,cAAc,QAAQ;AAChC,QAAA,KAAK,CAAC,CAAC,IAAI;AAAA,EAAA;AAGV,SAAA;AACT;AAOO,SAAS,WAAW,QAAgB;AAClC,SAAA,cAAc,QAAQ,GAAG;AAClC;AAOO,SAAS,YAAY,QAAgB;AACnC,SAAA,cAAc,QAAQ,GAAG;AAClC;AAOO,SAAS,cAAc,QAAgB;AACrC,SAAA,cAAc,QAAQ,GAAG;AAClC;AAOO,SAAS,cAAc,QAAgB;AACrC,SAAA,cAAc,QAAQ,GAAG;AAClC;;;;;;;"}
+{"version":3,"file":"time.cjs","names":[],"sources":["../src/time/from.ts","../src/time/to.ts"],"sourcesContent":["// @rer https://day.js.org/docs/en/durations/creating\n\nimport {\n  DATE_DAY_MS,\n  DATE_HOUR_MS,\n  DATE_MINUTE_MS,\n  DATE_MONTH_MS,\n  DATE_SECOND_MS,\n  DATE_YEAR_MS,\n} from '@/date';\nimport { isString } from '@/type';\nimport type { TimeDuration } from './to';\n\n/**\n * 时间转换规则数组\n * @type {Array<[RegExp, (match: RegExpMatchArray) => number]>}\n * @property {RegExp} 0 - 匹配时间单位正则表达式\n * @property {function} 1 - 将匹配结果转换为毫秒数的函数\n */\nconst rules: [key: keyof TimeDuration, time: number][] = [\n  ['years', DATE_YEAR_MS],\n  ['months', DATE_MONTH_MS],\n  ['days', DATE_DAY_MS],\n  ['hours', DATE_HOUR_MS],\n  ['minutes', DATE_MINUTE_MS],\n  ['seconds', DATE_SECOND_MS],\n];\n\n/**\n * 将时间持续时间字符串或对象转换为毫秒数\n *\n * @param duration - 可以是时间持续时间字符串（如 '1d2h'）或 TimeDuration 对象\n * @returns 计算得到的总毫秒数\n */\nexport function timeFrom(duration: string | TimeDuration) {\n  const td = isString(duration) ? timeParse(duration) : duration;\n  return rules.reduce((acc, [key, time]) => acc + (td[key] || 0) * time, 0);\n}\n\nconst durationMatchRules: [RegExp, key: keyof TimeDuration][] = [\n  [/(\\d+)y/i, 'years'],\n  [/(\\d+)M/, 'months'],\n  [/(\\d+)d/i, 'days'],\n  [/(\\d+)h/i, 'hours'],\n  [/(\\d+)m/, 'minutes'],\n  [/(\\d+)s/, 'seconds'],\n];\n\n/**\n * 将时长字符串解析为时间对象\n * @param duration - 时长字符串（例如 \"1h30m\"）\n * @returns 包含解析后时间单位的对象（小时、分钟等）\n */\nexport function timeParse(duration: string) {\n  const result = {} as TimeDuration;\n\n  for (const [regex, key] of durationMatchRules) {\n    const match = duration.match(regex);\n    if (match) result[key] = Number(match[1]);\n    else result[key] = 0;\n  }\n\n  return result;\n}\n","import {\n  DATE_DAY_MS,\n  DATE_HOUR_MS,\n  DATE_MINUTE_MS,\n  DATE_SECOND_MS,\n} from '../date';\n\nexport type TimeDuration = {\n  years: number;\n  months: number;\n  /** 天数 */\n  days: number;\n  /** 小时数 */\n  hours: number;\n  /** 分钟数 */\n  minutes: number;\n  /** 秒数 */\n  seconds: number;\n  /** 毫秒数 */\n  milliseconds: number;\n};\n\ntype _TTimeParsePoint = 'D' | 'h' | 'm' | 's' | 'S';\n\n/**\n * 解析时间毫秒数为绝对时间对象\n * @param timeMs 时间毫秒数\n * @param maxPoint 最大时间单位（决定分解的起始单位）\n * @returns 包含时间单位分解结果的对象\n * @example\n * ```typescript\n * // 默认以天为最大单位分解\n * timeInDay(123456789);\n * // { days: 1, hours: 10, minutes: 17, seconds: 36, milliseconds: 789 }\n *\n * // 指定最大单位为分钟，分解到分钟及以下单位\n * timeInMinute(123456789);\n * // { days: 0, hours: 0, minutes: 2057, seconds: 36, milliseconds: 789 }\n * ```\n */\nfunction _timeAbsolute(\n  timeMs: number,\n  maxPoint: _TTimeParsePoint,\n): TimeDuration {\n  const minPoint: _TTimeParsePoint = 'S';\n\n  const defines: [\n    point: _TTimeParsePoint,\n    key: keyof TimeDuration,\n    base: number,\n  ][] = [\n    ['D', 'days', DATE_DAY_MS],\n    ['h', 'hours', DATE_HOUR_MS],\n    ['m', 'minutes', DATE_MINUTE_MS],\n    ['s', 'seconds', DATE_SECOND_MS],\n    ['S', 'milliseconds', 1],\n  ] as const;\n\n  const minIndex = defines.findIndex((item) => item[0] === maxPoint);\n  const maxIndex = defines.findIndex((item) => item[0] === minPoint);\n\n  let timeMsFinal = timeMs;\n  const dao: TimeDuration = {\n    years: 0,\n    months: 0,\n    days: 0,\n    hours: 0,\n    minutes: 0,\n    seconds: 0,\n    milliseconds: 0,\n  };\n\n  for (let i = minIndex; i <= maxIndex; i++) {\n    const mode = defines[i];\n    const base = mode[2];\n    const value = Math.floor(timeMsFinal / base);\n    timeMsFinal = timeMsFinal - value * base;\n    dao[mode[1]] = value;\n  }\n\n  return dao;\n}\n\n/**\n * 将时间毫秒数解析为以天为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含天/小时/分钟/秒/毫秒分解结果的对象\n */\nexport function timeToDays(timeMs: number) {\n  return _timeAbsolute(timeMs, 'D');\n}\n\n/**\n * 将时间毫秒数解析为以小时为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含小时/分钟/秒/毫秒分解结果的对象\n */\nexport function timeToHours(timeMs: number) {\n  return _timeAbsolute(timeMs, 'h');\n}\n\n/**\n * 将时间毫秒数解析为以分钟为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含分钟/秒/毫秒分解结果的对象\n */\nexport function timeToMinutes(timeMs: number) {\n  return _timeAbsolute(timeMs, 'm');\n}\n\n/**\n * 将时间毫秒数解析为以秒为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含秒/毫秒分解结果的对象\n */\nexport function timeToSeconds(timeMs: number) {\n  return _timeAbsolute(timeMs, 's');\n}\n"],"mappings":";;;;;;;;;;AAmBA,IAAM,QAAmD;CACvD,CAAC,SAAS,aAAA,aAAa;CACvB,CAAC,UAAU,aAAA,cAAc;CACzB,CAAC,QAAQ,aAAA,YAAY;CACrB,CAAC,SAAS,aAAA,aAAa;CACvB,CAAC,WAAW,aAAA,eAAe;CAC3B,CAAC,WAAW,aAAA,eAAe;CAC5B;;;;;;;AAQD,SAAgB,SAAS,UAAiC;CACxD,MAAM,KAAK,aAAA,SAAS,SAAS,GAAG,UAAU,SAAS,GAAG;CACtD,OAAO,MAAM,QAAQ,KAAK,CAAC,KAAK,UAAU,OAAO,GAAG,QAAQ,KAAK,MAAM,EAAE;;AAG3E,IAAM,qBAA0D;CAC9D,CAAC,WAAW,QAAQ;CACpB,CAAC,UAAU,SAAS;CACpB,CAAC,WAAW,OAAO;CACnB,CAAC,WAAW,QAAQ;CACpB,CAAC,UAAU,UAAU;CACrB,CAAC,UAAU,UAAU;CACtB;;;;;;AAOD,SAAgB,UAAU,UAAkB;CAC1C,MAAM,SAAS,EAAE;CAEjB,KAAK,MAAM,CAAC,OAAO,QAAQ,oBAAoB;EAC7C,MAAM,QAAQ,SAAS,MAAM,MAAM;EACnC,IAAI,OAAO,OAAO,OAAO,OAAO,MAAM,GAAG;OACpC,OAAO,OAAO;;CAGrB,OAAO;;;;;;;;;;;;;;;;;;;;ACtBT,SAAS,cACP,QACA,UACc;CACd,MAAM,WAA6B;CAEnC,MAAM,UAIA;EACJ;GAAC;GAAK;GAAQ,aAAA;GAAY;EAC1B;GAAC;GAAK;GAAS,aAAA;GAAa;EAC5B;GAAC;GAAK;GAAW,aAAA;GAAe;EAChC;GAAC;GAAK;GAAW,aAAA;GAAe;EAChC;GAAC;GAAK;GAAgB;GAAE;EACzB;CAED,MAAM,WAAW,QAAQ,WAAW,SAAS,KAAK,OAAO,SAAS;CAClE,MAAM,WAAW,QAAQ,WAAW,SAAS,KAAK,OAAO,SAAS;CAElE,IAAI,cAAc;CAClB,MAAM,MAAoB;EACxB,OAAO;EACP,QAAQ;EACR,MAAM;EACN,OAAO;EACP,SAAS;EACT,SAAS;EACT,cAAc;EACf;CAED,KAAK,IAAI,IAAI,UAAU,KAAK,UAAU,KAAK;EACzC,MAAM,OAAO,QAAQ;EACrB,MAAM,OAAO,KAAK;EAClB,MAAM,QAAQ,KAAK,MAAM,cAAc,KAAK;EAC5C,cAAc,cAAc,QAAQ;EACpC,IAAI,KAAK,MAAM;;CAGjB,OAAO;;;;;;;AAQT,SAAgB,WAAW,QAAgB;CACzC,OAAO,cAAc,QAAQ,IAAI;;;;;;;AAQnC,SAAgB,YAAY,QAAgB;CAC1C,OAAO,cAAc,QAAQ,IAAI;;;;;;;AAQnC,SAAgB,cAAc,QAAgB;CAC5C,OAAO,cAAc,QAAQ,IAAI;;;;;;;AAQnC,SAAgB,cAAc,QAAgB;CAC5C,OAAO,cAAc,QAAQ,IAAI"}

package/dist/time.mjs

@@ -1,82 +1,153 @@
-import { D as DATE_YEAR_MS, a as DATE_MONTH_MS, b as DATE_DAY_MS, c as DATE_HOUR_MS, d as DATE_MINUTE_MS, e as DATE_SECOND_MS } from "./const.mjs";
 import { isString } from "./type.mjs";
-const rules = [
-  ["years", DATE_YEAR_MS],
-  ["months", DATE_MONTH_MS],
-  ["days", DATE_DAY_MS],
-  ["hours", DATE_HOUR_MS],
-  ["minutes", DATE_MINUTE_MS],
-  ["seconds", DATE_SECOND_MS]
+import { DATE_DAY_MS, DATE_HOUR_MS, DATE_MINUTE_MS, DATE_MONTH_MS, DATE_SECOND_MS, DATE_YEAR_MS } from "./date.mjs";
+//#region src/time/from.ts
+/**
+* 时间转换规则数组
+* @type {Array<[RegExp, (match: RegExpMatchArray) => number]>}
+* @property {RegExp} 0 - 匹配时间单位正则表达式
+* @property {function} 1 - 将匹配结果转换为毫秒数的函数
+*/
+var rules = [
+	["years", DATE_YEAR_MS],
+	["months", DATE_MONTH_MS],
+	["days", DATE_DAY_MS],
+	["hours", DATE_HOUR_MS],
+	["minutes", DATE_MINUTE_MS],
+	["seconds", DATE_SECOND_MS]
 ];
+/**
+* 将时间持续时间字符串或对象转换为毫秒数
+*
+* @param duration - 可以是时间持续时间字符串（如 '1d2h'）或 TimeDuration 对象
+* @returns 计算得到的总毫秒数
+*/
 function timeFrom(duration) {
-  const td = isString(duration) ? timeParse(duration) : duration;
-  return rules.reduce((acc, [key, time]) => acc + (td[key] || 0) * time, 0);
+	const td = isString(duration) ? timeParse(duration) : duration;
+	return rules.reduce((acc, [key, time]) => acc + (td[key] || 0) * time, 0);
 }
-const durationMatchRules = [
-  [/(\d+)y/i, "years"],
-  [/(\d+)M/, "months"],
-  [/(\d+)d/i, "days"],
-  [/(\d+)h/i, "hours"],
-  [/(\d+)m/, "minutes"],
-  [/(\d+)s/, "seconds"]
+var durationMatchRules = [
+	[/(\d+)y/i, "years"],
+	[/(\d+)M/, "months"],
+	[/(\d+)d/i, "days"],
+	[/(\d+)h/i, "hours"],
+	[/(\d+)m/, "minutes"],
+	[/(\d+)s/, "seconds"]
 ];
+/**
+* 将时长字符串解析为时间对象
+* @param duration - 时长字符串（例如 "1h30m"）
+* @returns 包含解析后时间单位的对象（小时、分钟等）
+*/
 function timeParse(duration) {
-  const result = {};
-  for (const [regex, key] of durationMatchRules) {
-    const match = duration.match(regex);
-    if (match) result[key] = Number(match[1]);
-    else result[key] = 0;
-  }
-  return result;
+	const result = {};
+	for (const [regex, key] of durationMatchRules) {
+		const match = duration.match(regex);
+		if (match) result[key] = Number(match[1]);
+		else result[key] = 0;
+	}
+	return result;
 }
+//#endregion
+//#region src/time/to.ts
+/**
+* 解析时间毫秒数为绝对时间对象
+* @param timeMs 时间毫秒数
+* @param maxPoint 最大时间单位（决定分解的起始单位）
+* @returns 包含时间单位分解结果的对象
+* @example
+* ```typescript
+* // 默认以天为最大单位分解
+* timeInDay(123456789);
+* // { days: 1, hours: 10, minutes: 17, seconds: 36, milliseconds: 789 }
+*
+* // 指定最大单位为分钟，分解到分钟及以下单位
+* timeInMinute(123456789);
+* // { days: 0, hours: 0, minutes: 2057, seconds: 36, milliseconds: 789 }
+* ```
+*/
 function _timeAbsolute(timeMs, maxPoint) {
-  const minPoint = "S";
-  const defines = [
-    ["D", "days", DATE_DAY_MS],
-    ["h", "hours", DATE_HOUR_MS],
-    ["m", "minutes", DATE_MINUTE_MS],
-    ["s", "seconds", DATE_SECOND_MS],
-    ["S", "milliseconds", 1]
-  ];
-  const minIndex = defines.findIndex((item) => item[0] === maxPoint);
-  const maxIndex = defines.findIndex((item) => item[0] === minPoint);
-  let timeMsFinal = timeMs;
-  const dao = {
-    years: 0,
-    months: 0,
-    days: 0,
-    hours: 0,
-    minutes: 0,
-    seconds: 0,
-    milliseconds: 0
-  };
-  for (let i = minIndex; i <= maxIndex; i++) {
-    const mode = defines[i];
-    const base = mode[2];
-    const value = Math.floor(timeMsFinal / base);
-    timeMsFinal = timeMsFinal - value * base;
-    dao[mode[1]] = value;
-  }
-  return dao;
+	const minPoint = "S";
+	const defines = [
+		[
+			"D",
+			"days",
+			DATE_DAY_MS
+		],
+		[
+			"h",
+			"hours",
+			DATE_HOUR_MS
+		],
+		[
+			"m",
+			"minutes",
+			DATE_MINUTE_MS
+		],
+		[
+			"s",
+			"seconds",
+			DATE_SECOND_MS
+		],
+		[
+			"S",
+			"milliseconds",
+			1
+		]
+	];
+	const minIndex = defines.findIndex((item) => item[0] === maxPoint);
+	const maxIndex = defines.findIndex((item) => item[0] === minPoint);
+	let timeMsFinal = timeMs;
+	const dao = {
+		years: 0,
+		months: 0,
+		days: 0,
+		hours: 0,
+		minutes: 0,
+		seconds: 0,
+		milliseconds: 0
+	};
+	for (let i = minIndex; i <= maxIndex; i++) {
+		const mode = defines[i];
+		const base = mode[2];
+		const value = Math.floor(timeMsFinal / base);
+		timeMsFinal = timeMsFinal - value * base;
+		dao[mode[1]] = value;
+	}
+	return dao;
 }
+/**
+* 将时间毫秒数解析为以天为最大单位的绝对时间对象
+* @param timeMs 时间毫秒数
+* @returns 包含天/小时/分钟/秒/毫秒分解结果的对象
+*/
 function timeToDays(timeMs) {
-  return _timeAbsolute(timeMs, "D");
+	return _timeAbsolute(timeMs, "D");
 }
+/**
+* 将时间毫秒数解析为以小时为最大单位的绝对时间对象
+* @param timeMs 时间毫秒数
+* @returns 包含小时/分钟/秒/毫秒分解结果的对象
+*/
 function timeToHours(timeMs) {
-  return _timeAbsolute(timeMs, "h");
+	return _timeAbsolute(timeMs, "h");
 }
+/**
+* 将时间毫秒数解析为以分钟为最大单位的绝对时间对象
+* @param timeMs 时间毫秒数
+* @returns 包含分钟/秒/毫秒分解结果的对象
+*/
 function timeToMinutes(timeMs) {
-  return _timeAbsolute(timeMs, "m");
+	return _timeAbsolute(timeMs, "m");
 }
+/**
+* 将时间毫秒数解析为以秒为最大单位的绝对时间对象
+* @param timeMs 时间毫秒数
+* @returns 包含秒/毫秒分解结果的对象
+*/
 function timeToSeconds(timeMs) {
-  return _timeAbsolute(timeMs, "s");
+	return _timeAbsolute(timeMs, "s");
 }
-export {
-  timeFrom,
-  timeParse,
-  timeToDays,
-  timeToHours,
-  timeToMinutes,
-  timeToSeconds
-};
-//# sourceMappingURL=time.mjs.map
+//#endregion
+export { timeFrom, timeParse, timeToDays, timeToHours, timeToMinutes, timeToSeconds };
+
+//# sourceMappingURL=time.mjs.map

package/dist/time.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"time.mjs","sources":["../src/time/from.ts","../src/time/to.ts"],"sourcesContent":["// @rer https://day.js.org/docs/en/durations/creating\n\nimport { DATE_DAY_MS, DATE_HOUR_MS, DATE_MINUTE_MS, DATE_MONTH_MS, DATE_SECOND_MS, DATE_YEAR_MS } from '@/date';\nimport { isString } from '@/type';\nimport type { TimeDuration } from './to';\n\n/**\n * 时间转换规则数组\n * @type {Array<[RegExp, (match: RegExpMatchArray) => number]>}\n * @property {RegExp} 0 - 匹配时间单位正则表达式\n * @property {function} 1 - 将匹配结果转换为毫秒数的函数\n */\nconst rules: [key: keyof TimeDuration, time: number][] = [\n  ['years', DATE_YEAR_MS],\n  ['months', DATE_MONTH_MS],\n  ['days', DATE_DAY_MS],\n  ['hours', DATE_HOUR_MS],\n  ['minutes', DATE_MINUTE_MS],\n  ['seconds', DATE_SECOND_MS],\n];\n\n/**\n * 将时间持续时间字符串或对象转换为毫秒数\n *\n * @param duration - 可以是时间持续时间字符串（如 '1d2h'）或 TimeDuration 对象\n * @returns 计算得到的总毫秒数\n */\nexport function timeFrom(duration: string | TimeDuration) {\n  const td = isString(duration) ? timeParse(duration) : duration;\n  return rules.reduce((acc, [key, time]) => acc + (td[key] || 0) * time, 0);\n}\n\nconst durationMatchRules: [RegExp, key: keyof TimeDuration][] = [\n  [/(\\d+)y/i, 'years'],\n  [/(\\d+)M/, 'months'],\n  [/(\\d+)d/i, 'days'],\n  [/(\\d+)h/i, 'hours'],\n  [/(\\d+)m/, 'minutes'],\n  [/(\\d+)s/, 'seconds'],\n];\n\n/**\n * 将时长字符串解析为时间对象\n * @param duration - 时长字符串（例如 \"1h30m\"）\n * @returns 包含解析后时间单位的对象（小时、分钟等）\n */\nexport function timeParse(duration: string) {\n  const result = {} as TimeDuration;\n\n  for (const [regex, key] of durationMatchRules) {\n    const match = duration.match(regex);\n    if (match) result[key] = Number(match[1]);\n    else result[key] = 0;\n  }\n\n  return result;\n}\n","import { DATE_DAY_MS, DATE_HOUR_MS, DATE_MINUTE_MS, DATE_SECOND_MS } from '../date';\n\nexport type TimeDuration = {\n  years: number;\n  months: number;\n  /** 天数 */\n  days: number;\n  /** 小时数 */\n  hours: number;\n  /** 分钟数 */\n  minutes: number;\n  /** 秒数 */\n  seconds: number;\n  /** 毫秒数 */\n  milliseconds: number;\n};\n\ntype _TTimeParsePoint = 'D' | 'h' | 'm' | 's' | 'S';\n\n/**\n * 解析时间毫秒数为绝对时间对象\n * @param timeMs 时间毫秒数\n * @param maxPoint 最大时间单位（决定分解的起始单位）\n * @returns 包含时间单位分解结果的对象\n * @example\n * ```typescript\n * // 默认以天为最大单位分解\n * timeInDay(123456789);\n * // { days: 1, hours: 10, minutes: 17, seconds: 36, milliseconds: 789 }\n *\n * // 指定最大单位为分钟，分解到分钟及以下单位\n * timeInMinute(123456789);\n * // { days: 0, hours: 0, minutes: 2057, seconds: 36, milliseconds: 789 }\n * ```\n */\nfunction _timeAbsolute(timeMs: number, maxPoint: _TTimeParsePoint): TimeDuration {\n  const minPoint: _TTimeParsePoint = 'S';\n\n  const defines: [point: _TTimeParsePoint, key: keyof TimeDuration, base: number][] = [\n    ['D', 'days', DATE_DAY_MS],\n    ['h', 'hours', DATE_HOUR_MS],\n    ['m', 'minutes', DATE_MINUTE_MS],\n    ['s', 'seconds', DATE_SECOND_MS],\n    ['S', 'milliseconds', 1],\n  ] as const;\n\n  const minIndex = defines.findIndex((item) => item[0] === maxPoint);\n  const maxIndex = defines.findIndex((item) => item[0] === minPoint);\n\n  let timeMsFinal = timeMs;\n  const dao: TimeDuration = {\n    years: 0,\n    months: 0,\n    days: 0,\n    hours: 0,\n    minutes: 0,\n    seconds: 0,\n    milliseconds: 0,\n  };\n\n  for (let i = minIndex; i <= maxIndex; i++) {\n    const mode = defines[i];\n    const base = mode[2];\n    const value = Math.floor(timeMsFinal / base);\n    timeMsFinal = timeMsFinal - value * base;\n    dao[mode[1]] = value;\n  }\n\n  return dao;\n}\n\n/**\n * 将时间毫秒数解析为以天为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含天/小时/分钟/秒/毫秒分解结果的对象\n */\nexport function timeToDays(timeMs: number) {\n  return _timeAbsolute(timeMs, 'D');\n}\n\n/**\n * 将时间毫秒数解析为以小时为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含小时/分钟/秒/毫秒分解结果的对象\n */\nexport function timeToHours(timeMs: number) {\n  return _timeAbsolute(timeMs, 'h');\n}\n\n/**\n * 将时间毫秒数解析为以分钟为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含分钟/秒/毫秒分解结果的对象\n */\nexport function timeToMinutes(timeMs: number) {\n  return _timeAbsolute(timeMs, 'm');\n}\n\n/**\n * 将时间毫秒数解析为以秒为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含秒/毫秒分解结果的对象\n */\nexport function timeToSeconds(timeMs: number) {\n  return _timeAbsolute(timeMs, 's');\n}\n"],"names":[],"mappings":";;AAYA,MAAM,QAAmD;AAAA,EACvD,CAAC,SAAS,YAAY;AAAA,EACtB,CAAC,UAAU,aAAa;AAAA,EACxB,CAAC,QAAQ,WAAW;AAAA,EACpB,CAAC,SAAS,YAAY;AAAA,EACtB,CAAC,WAAW,cAAc;AAAA,EAC1B,CAAC,WAAW,cAAc;AAC5B;AAQO,SAAS,SAAS,UAAiC;AACxD,QAAM,KAAK,SAAS,QAAQ,IAAI,UAAU,QAAQ,IAAI;AACtD,SAAO,MAAM,OAAO,CAAC,KAAK,CAAC,KAAK,IAAI,MAAM,OAAO,GAAG,GAAG,KAAK,KAAK,MAAM,CAAC;AAC1E;AAEA,MAAM,qBAA0D;AAAA,EAC9D,CAAC,WAAW,OAAO;AAAA,EACnB,CAAC,UAAU,QAAQ;AAAA,EACnB,CAAC,WAAW,MAAM;AAAA,EAClB,CAAC,WAAW,OAAO;AAAA,EACnB,CAAC,UAAU,SAAS;AAAA,EACpB,CAAC,UAAU,SAAS;AACtB;AAOO,SAAS,UAAU,UAAkB;AAC1C,QAAM,SAAS,CAAC;AAEhB,aAAW,CAAC,OAAO,GAAG,KAAK,oBAAoB;AACvC,UAAA,QAAQ,SAAS,MAAM,KAAK;AAClC,QAAI,MAAc,QAAA,GAAG,IAAI,OAAO,MAAM,CAAC,CAAC;AAAA,QACnC,QAAO,GAAG,IAAI;AAAA,EAAA;AAGd,SAAA;AACT;ACrBA,SAAS,cAAc,QAAgB,UAA0C;AAC/E,QAAM,WAA6B;AAEnC,QAAM,UAA8E;AAAA,IAClF,CAAC,KAAK,QAAQ,WAAW;AAAA,IACzB,CAAC,KAAK,SAAS,YAAY;AAAA,IAC3B,CAAC,KAAK,WAAW,cAAc;AAAA,IAC/B,CAAC,KAAK,WAAW,cAAc;AAAA,IAC/B,CAAC,KAAK,gBAAgB,CAAC;AAAA,EACzB;AAEM,QAAA,WAAW,QAAQ,UAAU,CAAC,SAAS,KAAK,CAAC,MAAM,QAAQ;AAC3D,QAAA,WAAW,QAAQ,UAAU,CAAC,SAAS,KAAK,CAAC,MAAM,QAAQ;AAEjE,MAAI,cAAc;AAClB,QAAM,MAAoB;AAAA,IACxB,OAAO;AAAA,IACP,QAAQ;AAAA,IACR,MAAM;AAAA,IACN,OAAO;AAAA,IACP,SAAS;AAAA,IACT,SAAS;AAAA,IACT,cAAc;AAAA,EAChB;AAEA,WAAS,IAAI,UAAU,KAAK,UAAU,KAAK;AACnC,UAAA,OAAO,QAAQ,CAAC;AAChB,UAAA,OAAO,KAAK,CAAC;AACnB,UAAM,QAAQ,KAAK,MAAM,cAAc,IAAI;AAC3C,kBAAc,cAAc,QAAQ;AAChC,QAAA,KAAK,CAAC,CAAC,IAAI;AAAA,EAAA;AAGV,SAAA;AACT;AAOO,SAAS,WAAW,QAAgB;AAClC,SAAA,cAAc,QAAQ,GAAG;AAClC;AAOO,SAAS,YAAY,QAAgB;AACnC,SAAA,cAAc,QAAQ,GAAG;AAClC;AAOO,SAAS,cAAc,QAAgB;AACrC,SAAA,cAAc,QAAQ,GAAG;AAClC;AAOO,SAAS,cAAc,QAAgB;AACrC,SAAA,cAAc,QAAQ,GAAG;AAClC;"}
+{"version":3,"file":"time.mjs","names":[],"sources":["../src/time/from.ts","../src/time/to.ts"],"sourcesContent":["// @rer https://day.js.org/docs/en/durations/creating\n\nimport {\n  DATE_DAY_MS,\n  DATE_HOUR_MS,\n  DATE_MINUTE_MS,\n  DATE_MONTH_MS,\n  DATE_SECOND_MS,\n  DATE_YEAR_MS,\n} from '@/date';\nimport { isString } from '@/type';\nimport type { TimeDuration } from './to';\n\n/**\n * 时间转换规则数组\n * @type {Array<[RegExp, (match: RegExpMatchArray) => number]>}\n * @property {RegExp} 0 - 匹配时间单位正则表达式\n * @property {function} 1 - 将匹配结果转换为毫秒数的函数\n */\nconst rules: [key: keyof TimeDuration, time: number][] = [\n  ['years', DATE_YEAR_MS],\n  ['months', DATE_MONTH_MS],\n  ['days', DATE_DAY_MS],\n  ['hours', DATE_HOUR_MS],\n  ['minutes', DATE_MINUTE_MS],\n  ['seconds', DATE_SECOND_MS],\n];\n\n/**\n * 将时间持续时间字符串或对象转换为毫秒数\n *\n * @param duration - 可以是时间持续时间字符串（如 '1d2h'）或 TimeDuration 对象\n * @returns 计算得到的总毫秒数\n */\nexport function timeFrom(duration: string | TimeDuration) {\n  const td = isString(duration) ? timeParse(duration) : duration;\n  return rules.reduce((acc, [key, time]) => acc + (td[key] || 0) * time, 0);\n}\n\nconst durationMatchRules: [RegExp, key: keyof TimeDuration][] = [\n  [/(\\d+)y/i, 'years'],\n  [/(\\d+)M/, 'months'],\n  [/(\\d+)d/i, 'days'],\n  [/(\\d+)h/i, 'hours'],\n  [/(\\d+)m/, 'minutes'],\n  [/(\\d+)s/, 'seconds'],\n];\n\n/**\n * 将时长字符串解析为时间对象\n * @param duration - 时长字符串（例如 \"1h30m\"）\n * @returns 包含解析后时间单位的对象（小时、分钟等）\n */\nexport function timeParse(duration: string) {\n  const result = {} as TimeDuration;\n\n  for (const [regex, key] of durationMatchRules) {\n    const match = duration.match(regex);\n    if (match) result[key] = Number(match[1]);\n    else result[key] = 0;\n  }\n\n  return result;\n}\n","import {\n  DATE_DAY_MS,\n  DATE_HOUR_MS,\n  DATE_MINUTE_MS,\n  DATE_SECOND_MS,\n} from '../date';\n\nexport type TimeDuration = {\n  years: number;\n  months: number;\n  /** 天数 */\n  days: number;\n  /** 小时数 */\n  hours: number;\n  /** 分钟数 */\n  minutes: number;\n  /** 秒数 */\n  seconds: number;\n  /** 毫秒数 */\n  milliseconds: number;\n};\n\ntype _TTimeParsePoint = 'D' | 'h' | 'm' | 's' | 'S';\n\n/**\n * 解析时间毫秒数为绝对时间对象\n * @param timeMs 时间毫秒数\n * @param maxPoint 最大时间单位（决定分解的起始单位）\n * @returns 包含时间单位分解结果的对象\n * @example\n * ```typescript\n * // 默认以天为最大单位分解\n * timeInDay(123456789);\n * // { days: 1, hours: 10, minutes: 17, seconds: 36, milliseconds: 789 }\n *\n * // 指定最大单位为分钟，分解到分钟及以下单位\n * timeInMinute(123456789);\n * // { days: 0, hours: 0, minutes: 2057, seconds: 36, milliseconds: 789 }\n * ```\n */\nfunction _timeAbsolute(\n  timeMs: number,\n  maxPoint: _TTimeParsePoint,\n): TimeDuration {\n  const minPoint: _TTimeParsePoint = 'S';\n\n  const defines: [\n    point: _TTimeParsePoint,\n    key: keyof TimeDuration,\n    base: number,\n  ][] = [\n    ['D', 'days', DATE_DAY_MS],\n    ['h', 'hours', DATE_HOUR_MS],\n    ['m', 'minutes', DATE_MINUTE_MS],\n    ['s', 'seconds', DATE_SECOND_MS],\n    ['S', 'milliseconds', 1],\n  ] as const;\n\n  const minIndex = defines.findIndex((item) => item[0] === maxPoint);\n  const maxIndex = defines.findIndex((item) => item[0] === minPoint);\n\n  let timeMsFinal = timeMs;\n  const dao: TimeDuration = {\n    years: 0,\n    months: 0,\n    days: 0,\n    hours: 0,\n    minutes: 0,\n    seconds: 0,\n    milliseconds: 0,\n  };\n\n  for (let i = minIndex; i <= maxIndex; i++) {\n    const mode = defines[i];\n    const base = mode[2];\n    const value = Math.floor(timeMsFinal / base);\n    timeMsFinal = timeMsFinal - value * base;\n    dao[mode[1]] = value;\n  }\n\n  return dao;\n}\n\n/**\n * 将时间毫秒数解析为以天为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含天/小时/分钟/秒/毫秒分解结果的对象\n */\nexport function timeToDays(timeMs: number) {\n  return _timeAbsolute(timeMs, 'D');\n}\n\n/**\n * 将时间毫秒数解析为以小时为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含小时/分钟/秒/毫秒分解结果的对象\n */\nexport function timeToHours(timeMs: number) {\n  return _timeAbsolute(timeMs, 'h');\n}\n\n/**\n * 将时间毫秒数解析为以分钟为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含分钟/秒/毫秒分解结果的对象\n */\nexport function timeToMinutes(timeMs: number) {\n  return _timeAbsolute(timeMs, 'm');\n}\n\n/**\n * 将时间毫秒数解析为以秒为最大单位的绝对时间对象\n * @param timeMs 时间毫秒数\n * @returns 包含秒/毫秒分解结果的对象\n */\nexport function timeToSeconds(timeMs: number) {\n  return _timeAbsolute(timeMs, 's');\n}\n"],"mappings":";;;;;;;;;AAmBA,IAAM,QAAmD;CACvD,CAAC,SAAS,aAAa;CACvB,CAAC,UAAU,cAAc;CACzB,CAAC,QAAQ,YAAY;CACrB,CAAC,SAAS,aAAa;CACvB,CAAC,WAAW,eAAe;CAC3B,CAAC,WAAW,eAAe;CAC5B;;;;;;;AAQD,SAAgB,SAAS,UAAiC;CACxD,MAAM,KAAK,SAAS,SAAS,GAAG,UAAU,SAAS,GAAG;CACtD,OAAO,MAAM,QAAQ,KAAK,CAAC,KAAK,UAAU,OAAO,GAAG,QAAQ,KAAK,MAAM,EAAE;;AAG3E,IAAM,qBAA0D;CAC9D,CAAC,WAAW,QAAQ;CACpB,CAAC,UAAU,SAAS;CACpB,CAAC,WAAW,OAAO;CACnB,CAAC,WAAW,QAAQ;CACpB,CAAC,UAAU,UAAU;CACrB,CAAC,UAAU,UAAU;CACtB;;;;;;AAOD,SAAgB,UAAU,UAAkB;CAC1C,MAAM,SAAS,EAAE;CAEjB,KAAK,MAAM,CAAC,OAAO,QAAQ,oBAAoB;EAC7C,MAAM,QAAQ,SAAS,MAAM,MAAM;EACnC,IAAI,OAAO,OAAO,OAAO,OAAO,MAAM,GAAG;OACpC,OAAO,OAAO;;CAGrB,OAAO;;;;;;;;;;;;;;;;;;;;ACtBT,SAAS,cACP,QACA,UACc;CACd,MAAM,WAA6B;CAEnC,MAAM,UAIA;EACJ;GAAC;GAAK;GAAQ;GAAY;EAC1B;GAAC;GAAK;GAAS;GAAa;EAC5B;GAAC;GAAK;GAAW;GAAe;EAChC;GAAC;GAAK;GAAW;GAAe;EAChC;GAAC;GAAK;GAAgB;GAAE;EACzB;CAED,MAAM,WAAW,QAAQ,WAAW,SAAS,KAAK,OAAO,SAAS;CAClE,MAAM,WAAW,QAAQ,WAAW,SAAS,KAAK,OAAO,SAAS;CAElE,IAAI,cAAc;CAClB,MAAM,MAAoB;EACxB,OAAO;EACP,QAAQ;EACR,MAAM;EACN,OAAO;EACP,SAAS;EACT,SAAS;EACT,cAAc;EACf;CAED,KAAK,IAAI,IAAI,UAAU,KAAK,UAAU,KAAK;EACzC,MAAM,OAAO,QAAQ;EACrB,MAAM,OAAO,KAAK;EAClB,MAAM,QAAQ,KAAK,MAAM,cAAc,KAAK;EAC5C,cAAc,cAAc,QAAQ;EACpC,IAAI,KAAK,MAAM;;CAGjB,OAAO;;;;;;;AAQT,SAAgB,WAAW,QAAgB;CACzC,OAAO,cAAc,QAAQ,IAAI;;;;;;;AAQnC,SAAgB,YAAY,QAAgB;CAC1C,OAAO,cAAc,QAAQ,IAAI;;;;;;;AAQnC,SAAgB,cAAc,QAAgB;CAC5C,OAAO,cAAc,QAAQ,IAAI;;;;;;;AAQnC,SAAgB,cAAc,QAAgB;CAC5C,OAAO,cAAc,QAAQ,IAAI"}