zzz-pc-view 0.0.1

package/src/utils/Date/ZDate.d.ts

@@ -0,0 +1,557 @@
+import { WithoutFirst, WithoutFirstParams } from '../DeclareType';
+/**
+ * 表示最小毫秒数的类型，可能为空字符串或'.000'。
+ */
+type MinMsType = '.000' | '';
+/**
+ * 表示最大毫秒数的类型，可能为空字符串或'.999'。
+ */
+type MaxMsType = '.999' | '';
+/**
+ * 表示是否为 UTC 时间的字符串类型，可能为 'UTC' 或空字符串。
+ */
+type UTCStr = 'UTC' | '';
+/**
+ * 定义一个类型别名 `WeekDays`，表示一周中的每一天。
+ * 该类型是一个联合类型，包含从 0 到 6 的数字，分别对应星期日到星期六。
+ */
+type WeekDays = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+/**
+ * 获取指定日期所在周的第一天。
+ *
+ * @param {ZDate} date - 目标日期对象。
+ * @param {boolean} isUTC - 是否使用UTC时间。
+ * @param {WeekDays} fromDay - 周的起始日，默认为星期日（0）。
+ * @param {0 | 1} firstWeekDiff - 用于调整第一周的差异，默认为0。
+ * @returns {ZDate} - 返回指定日期所在周的第一天的日期对象。
+ */
+declare const getWeekFirstDate: (date: ZDate, isUTC: boolean, fromDay?: WeekDays, firstWeekDiff?: 0 | 1) => ZDate;
+/**
+ * 定义一个类型别名 `WeekParams`，它是从 `getWeekFirstDate` 函数的参数中提取出来的。
+ * `WithoutFirst` 是一个工具类型，用于从一个元组类型中移除第一个元素。
+ * 因此，`WeekParams` 类型将包含 `getWeekFirstDate` 函数除了第一个参数（即 `date`）之外的所有参数。
+ */
+export type WeekParams = WithoutFirst<WithoutFirstParams<typeof getWeekFirstDate>>;
+/**
+ * 日期格式化工具数组，包含不同日期单位的格式化配置
+ */
+declare const formatUtils: readonly [{
+    readonly dateUnit: "FullYear";
+    readonly formatChar: "Y";
+    readonly formatRegExp: RegExp;
+    readonly formatDiff: 0;
+    /**
+     * 根据指定的格式字符串和日期对象生成格式化的日期字符串。
+     *
+     * @param {string} format - 格式化字符串，例如 'YYYY/MM/DD HH:mm:ss'。
+     * @param {ZDate} date - 要格式化的日期对象。
+     * @param {UTCStr} utcStr - 表示是否为 UTC 时间的字符串，可能为 'UTC' 或空字符串。
+     * @returns {string} - 格式化后的日期字符串。
+     */
+    readonly getFormatStr: (format: string, date: ZDate, utcStr: UTCStr) => string;
+    /**
+     * 获取指定日期的最小时间格式字符串。
+     *
+     * @param {MinMsType} msStr - 最小毫秒数的类型，可能为空字符串或'.000'。
+     * @returns {string} - 最小时间格式字符串。
+     */
+    readonly getMinTimeFormat: (msStr: MinMsType) => string;
+    /**
+     * 获取指定日期的最大时间格式字符串。
+     *
+     * @param {MaxMsType} msStr - 最大毫秒数的类型，可能为空字符串或'.999'。
+     * @returns {string} - 最大时间格式字符串。
+     */
+    readonly getMaxTimeFormat: (msStr: MaxMsType) => string;
+}, {
+    readonly dateUnit: "Quarter";
+    readonly formatChar: "Q";
+    readonly formatRegExp: RegExp;
+    readonly formatDiff: 0;
+    /**
+     * 根据指定的格式字符串和日期对象生成格式化的日期字符串。
+     *
+     * @param {string} format - 格式化字符串，例如 'YYYY/MM/DD HH:mm:ss'。
+     * @param {ZDate} date - 要格式化的日期对象。
+     * @param {UTCStr} utcStr - 表示是否为 UTC 时间的字符串，可能为 'UTC' 或空字符串。
+     * @returns {string} - 格式化后的日期字符串。
+     */
+    readonly getFormatStr: (format: string, date: ZDate, utcStr: UTCStr) => string;
+    /**
+     * 获取指定日期的最小时间格式字符串。
+     *
+     * @param {MinMsType} msStr - 最小毫秒数的类型，可能为空字符串或'.000'。
+     * @param {ZDate} date - 要格式化的日期对象。
+     * @returns {string} - 最小时间格式字符串。
+     */
+    readonly getMinTimeFormat: (msStr: MinMsType, date: ZDate) => string;
+    /**
+     * 获取指定日期的最大时间格式字符串。
+     *
+     * @param {MaxMsType} msStr - 最大毫秒数的类型，可能为空字符串或'.999'。
+     * @param {ZDate} date - 要格式化的日期对象。
+     * @returns {string} - 最大时间格式字符串。
+     */
+    readonly getMaxTimeFormat: (msStr: MaxMsType, date: ZDate) => string;
+}, {
+    readonly dateUnit: "Month";
+    readonly formatChar: "M";
+    readonly formatRegExp: RegExp;
+    readonly formatDiff: 1;
+    /**
+     * 根据指定的格式字符串和日期对象生成格式化的日期字符串。
+     *
+     * @param {string} format - 格式化字符串，例如 'YYYY/MM/DD HH:mm:ss'。
+     * @param {ZDate} date - 要格式化的日期对象。
+     * @param {UTCStr} utcStr - 表示是否为 UTC 时间的字符串，可能为 'UTC' 或空字符串。
+     * @returns {string} - 格式化后的日期字符串。
+     */
+    readonly getFormatStr: (format: string, date: ZDate, utcStr: UTCStr) => string;
+    /**
+     * 获取指定日期的最小时间格式字符串。
+     *
+     * @param {MinMsType} msStr - 最小毫秒数的类型，可能为空字符串或'.000'。
+     * @returns {string} - 最小时间格式字符串。
+     */
+    readonly getMinTimeFormat: (msStr: MinMsType) => string;
+    /**
+     * 获取指定日期的最大时间格式字符串。
+     *
+     * @param {MaxMsType} msStr - 最大毫秒数的类型，可能为空字符串或'.999'。
+     * @param {ZDate} date - 要格式化的日期对象。
+     * @returns {string} - 最大时间格式字符串。
+     */
+    readonly getMaxTimeFormat: (msStr: MaxMsType, date: ZDate) => string;
+}, {
+    readonly dateUnit: "Week";
+    readonly formatChar: "W";
+    readonly formatRegExp: RegExp;
+    readonly formatDiff: 0;
+    /**
+     * 根据指定的格式字符串、日期对象、是否为UTC时间以及周的起始日和第一周差异生成格式化的日期字符串。
+     *
+     * @param {string} format - 格式化字符串，例如 'YYYY/MM/DD HH:mm:ss'。
+     * @param {ZDate} date - 要格式化的日期对象。
+     * @param {UTCStr} utcStr - 表示是否为 UTC 时间的字符串，可能为 'UTC' 或空字符串。
+     * @param {WeekDays} fromDay - 周的起始日，默认为0（星期日）。
+     * @param {0 | 1} firstWeekDiff - 第一周差异，默认为0。
+     * @returns {string} - 格式化后的日期字符串。
+     */
+    readonly getFormatStr: (format: string, date: ZDate, utcStr: UTCStr, fromDay?: WeekDays, firstWeekDiff?: 0 | 1) => string;
+    /**
+     * 获取指定日期的最小时间格式字符串。
+     *
+     * @param {MinMsType} msStr - 最小毫秒数的类型，可能为空字符串或'.000'。
+     * @param {ZDate} date - 要格式化的日期对象。
+     * @param {...WeekParams} weekParams - 用于计算周数的起始日期的可选参数。
+     * @returns {string} - 最小时间格式字符串。
+     */
+    readonly getMinTimeFormat: (msStr: MinMsType, date: ZDate, fromDay?: WeekDays | undefined, firstWeekDiff?: 0 | 1 | undefined) => string;
+    /**
+     * 获取指定日期的最大时间格式字符串。
+     *
+     * @param {MaxMsType} msStr - 最大毫秒数的类型，可能为空字符串或'.999'。
+     * @param {ZDate} date - 要格式化的日期对象。
+     * @param {...WeekParams} weekParams - 用于计算周数的起始日期的可选参数。
+     * @returns {string} - 最大时间格式字符串。
+     */
+    readonly getMaxTimeFormat: (msStr: MaxMsType, date: ZDate, fromDay?: WeekDays | undefined, firstWeekDiff?: 0 | 1 | undefined) => string;
+}, {
+    readonly dateUnit: "Date";
+    readonly formatChar: "D";
+    readonly formatRegExp: RegExp;
+    readonly formatDiff: 0;
+    /**
+     * 根据指定的格式字符串、日期对象和是否为UTC时间生成格式化的日期字符串。
+     *
+     * @param {string} format - 格式化字符串，例如 'YYYY/MM/DD HH:mm:ss'。
+     * @param {ZDate} date - 要格式化的日期对象。
+     * @param {UTCStr} utcStr - 表示是否为 UTC 时间的字符串，可能为 'UTC' 或空字符串。
+     * @returns {string} - 格式化后的日期字符串。
+     */
+    readonly getFormatStr: (format: string, date: ZDate, utcStr: UTCStr) => string;
+    /**
+     * 获取指定日期的最小时间格式字符串。
+     *
+     * @param {MinMsType} msStr - 最小毫秒数的类型，可能为空字符串或'.000'。
+     * @returns {string} - 最小时间格式字符串。
+     */
+    readonly getMinTimeFormat: (msStr: MinMsType) => string;
+    /**
+     * 获取指定日期的最大时间格式字符串。
+     *
+     * @param {MaxMsType} msStr - 最大毫秒数的类型，可能为空字符串或'.999'。
+     * @returns {string} - 最大时间格式字符串。
+     */
+    readonly getMaxTimeFormat: (msStr: MaxMsType) => string;
+}, {
+    readonly dateUnit: "Hours";
+    readonly formatChar: "H";
+    readonly formatRegExp: RegExp;
+    readonly formatDiff: 0;
+    /**
+     * 根据指定的格式字符串、日期对象和是否为UTC时间生成格式化的日期字符串。
+     *
+     * @param {string} format - 格式化字符串，例如 'YYYY/MM/DD HH:mm:ss'。
+     * @param {ZDate} date - 要格式化的日期对象。
+     * @param {UTCStr} utcStr - 表示是否为 UTC 时间的字符串，可能为 'UTC' 或空字符串。
+     * @returns {string} - 格式化后的日期字符串。
+     */
+    readonly getFormatStr: (format: string, date: ZDate, utcStr: UTCStr) => string;
+    /**
+     * 获取指定日期的最小时间格式字符串。
+     *
+     * @param {MinMsType} msStr - 最小毫秒数的类型，可能为空字符串或'.000'。
+     * @returns {string} - 最小时间格式字符串。
+     */
+    readonly getMinTimeFormat: (msStr: MinMsType) => string;
+    /**
+     * 获取指定日期的最大时间格式字符串。
+     *
+     * @param {MaxMsType} msStr - 最大毫秒数的类型，可能为空字符串或'.999'。
+     * @returns {string} - 最大时间格式字符串。
+     */
+    readonly getMaxTimeFormat: (msStr: MaxMsType) => string;
+}, {
+    readonly dateUnit: "Minutes";
+    readonly formatChar: "m";
+    readonly formatRegExp: RegExp;
+    readonly formatDiff: 0;
+    /**
+     * 根据指定的格式字符串、日期对象和是否为UTC时间生成格式化的日期字符串。
+     *
+     * @param {string} format - 格式化字符串，例如 'YYYY/MM/DD HH:mm:ss'。
+     * @param {ZDate} date - 要格式化的日期对象。
+     * @param {UTCStr} utcStr - 表示是否为 UTC 时间的字符串，可能为 'UTC' 或空字符串。
+     * @returns {string} - 格式化后的日期字符串。
+     */
+    readonly getFormatStr: (format: string, date: ZDate, utcStr: UTCStr) => string;
+    /**
+     * 获取指定日期的最小时间格式字符串。
+     *
+     * @param {MinMsType} msStr - 最小毫秒数的类型，可能为空字符串或'.000'。
+     * @returns {string} - 最小时间格式字符串。
+     */
+    readonly getMinTimeFormat: (msStr: MinMsType) => string;
+    /**
+     * 获取指定日期的最大时间格式字符串。
+     *
+     * @param {MaxMsType} msStr - 最大毫秒数的类型，可能为空字符串或'.999'。
+     * @returns {string} - 最大时间格式字符串。
+     */
+    readonly getMaxTimeFormat: (msStr: MaxMsType) => string;
+}, {
+    readonly dateUnit: "Seconds";
+    readonly formatChar: "s";
+    readonly formatRegExp: RegExp;
+    readonly formatDiff: 0;
+    /**
+     * 根据指定的格式字符串、日期对象和是否为UTC时间生成格式化的日期字符串。
+     *
+     * @param {string} format - 格式化字符串，例如 'YYYY/MM/DD HH:mm:ss'。
+     * @param {ZDate} date - 要格式化的日期对象。
+     * @param {UTCStr} utcStr - 表示是否为 UTC 时间的字符串，可能为 'UTC' 或空字符串。
+     * @returns {string} - 格式化后的日期字符串。
+     */
+    readonly getFormatStr: (format: string, date: ZDate, utcStr: UTCStr) => string;
+    /**
+     * 获取指定日期的最小时间格式字符串。
+     *
+     * @param {MinMsType} msStr - 最小毫秒数的类型，可能为空字符串或'.000'。
+     * @returns {string} - 最小时间格式字符串。
+     */
+    readonly getMinTimeFormat: (msStr: MinMsType) => string;
+    /**
+     * 获取指定日期的最大时间格式字符串。
+     *
+     * @param {MaxMsType} msStr - 最大毫秒数的类型，可能为空字符串或'.999'。
+     * @returns {string} - 最大时间格式字符串。
+     */
+    readonly getMaxTimeFormat: (msStr: MaxMsType) => string;
+}, {
+    readonly dateUnit: "Milliseconds";
+    readonly formatChar: "S";
+    readonly formatRegExp: RegExp;
+    readonly formatDiff: 0;
+    /**
+     * 根据指定的格式字符串、日期对象和是否为UTC时间生成格式化的日期字符串。
+     *
+     * @param {string} format - 格式化字符串，例如 'YYYY/MM/DD HH:mm:ss'。
+     * @param {ZDate} date - 要格式化的日期对象。
+     * @param {UTCStr} utcStr - 表示是否为 UTC 时间的字符串，可能为 'UTC' 或空字符串。
+     * @returns {string} - 格式化后的日期字符串。
+     */
+    readonly getFormatStr: (format: string, date: ZDate, utcStr: UTCStr) => string;
+    /**
+     * 获取指定日期的最小时间格式字符串。
+     *
+     * @returns {string} - 最小时间格式字符串。
+     */
+    readonly getMinTimeFormat: () => string;
+    /**
+     * 获取指定日期的最大时间格式字符串。
+     *
+     * @returns {string} - 最大时间格式字符串。
+     */
+    readonly getMaxTimeFormat: () => string;
+}];
+/**
+ * 定义了一个类型别名 `FormatUtils`，它是 `formatUtils` 数组的类型。
+ * `formatUtils` 数组包含了多个用于格式化日期的工具对象。
+ */
+type FormatUtils = typeof formatUtils;
+/**
+ * 定义了一个类型别名 `FormatUtil`，它是 `FormatUtils` 数组中的单个元素的类型。
+ * 即表示一个用于格式化日期的工具对象。
+ */
+type FormatUtil = FormatUtils[number];
+/**
+ * 定义了一个类型别名 `ZDateUnit`，它是 `FormatUtil` 对象中的 `dateUnit` 属性的类型。
+ * `dateUnit` 属性表示日期的单位，如 'Hours'、'Minutes' 等。
+ */
+export type ZDateUnit = FormatUtil['dateUnit'];
+/**
+ * 根据指定的格式、日期对象和是否为UTC时间生成格式化的日期字符串。
+ *
+ * @param date - 要格式化的日期对象。
+ * @param format - 格式化字符串，默认为 'YYYY/MM/DD HH:mm:ss'。
+ * @param isUTC - 是否为UTC时间，默认为 false。
+ * @param params - 可选参数，用于格式化日期。
+ * @returns 格式化后的日期字符串。
+ */
+declare const getFormatStr: (date: ZDate, format?: string, isUTC?: boolean, fromDay?: WeekDays | undefined, firstWeekDiff?: 0 | 1 | undefined) => string;
+/**
+ * 获取指定日期的最小时间格式字符串。
+ *
+ * @param date - 要格式化的日期对象。
+ * @param dateUnit - 日期单位，排除毫秒。
+ * @param withMs - 是否包含毫秒，默认为 false。
+ * @param params - 可选参数，用于格式化日期。
+ * @returns 最小时间格式字符串。
+ */
+declare const getMinTimeFormat: (date: ZDate, dateUnit: Exclude<ZDateUnit, "Milliseconds">, withMs?: boolean, fromDay?: WeekDays | undefined, firstWeekDiff?: 0 | 1 | undefined) => string;
+/**
+ * 获取指定日期的最大时间格式字符串。
+ *
+ * @param date - 要格式化的日期对象。
+ * @param dateUnit - 日期单位，排除毫秒。
+ * @param withMs - 是否包含毫秒，默认为 false。
+ * @param params - 可选参数，用于格式化日期。
+ * @returns 最大时间格式字符串。
+ */
+declare const getMaxTimeFormat: (date: ZDate, dateUnit: Exclude<ZDateUnit, "Milliseconds">, withMs?: boolean, fromDay?: WeekDays | undefined, firstWeekDiff?: 0 | 1 | undefined) => string;
+/**
+ * 根据指定的格式字符串设置日期对象的时间。
+ *
+ * @param date - 要设置的日期对象。
+ * @param dateStr - 包含日期和时间的字符串。
+ * @param format - 格式化字符串。
+ * @param params - 可选参数，用于格式化日期。
+ * @returns 设置后的日期对象的时间戳。
+ */
+declare const setDateByFormat: (date: ZDate, dateStr: string, format: string, fromDay?: WeekDays | undefined, firstWeekDiff?: 0 | 1 | undefined) => number;
+/**
+ * 自定义日期类，继承自 JavaScript 的内置 `Date` 类。
+ * 提供了一些额外的方法来处理日期和时间。
+ */
+export declare class ZDate extends Date {
+    /**
+     * 设置日期的季度。
+     * @param {number} quarter - 季度数。
+     * @returns {number} - 返回当前日期的时间戳。
+     *
+     * @example
+        const date = new ZDate('2024/01/01 00:00:00')
+        date.setQuarter(3)
+     * // 输出 1719763200000
+     */
+    setQuarter(quarter: number): number;
+    /**
+     * 获取日期的季度。
+     * @returns {number} - 返回当前日期所属的季度，范围从 1 到 4。
+     *
+     * @example new ZDate('2024/01/01 00:00:00').getQuarter()
+     * // 输出 1
+     */
+    getQuarter(): number;
+    /**
+     * 设置日期的 UTC 季度。
+     * @param {number} quarter - 季度数。
+     * @returns {number} - 返回当前日期的 UTC 时间戳。
+     *
+     * @example
+        const date = new ZDate('2024/01/01 00:00:00')
+        date.setUTCQuarter(3)
+     * // 输出 1688227200000
+     */
+    setUTCQuarter(quarter: number): number;
+    /**
+     * 获取日期的 UTC 季度。
+     * @returns {number} - 返回当前日期所属的 UTC 季度，范围从 1 到 4。
+     *
+     * @example new ZDate('2024/01/01 00:00:00').getUTCQuarter()
+     * // 输出 4
+     */
+    getUTCQuarter(): number;
+    /**
+     * 设置日期的周数。
+     * @param {number} week - 周数，范围从 1 开始。
+     * @param fromDay — 周的起始日，默认为星期日（0）。
+     * @param firstWeekDiff — 用于调整第一周的差异，默认为0。
+     * @returns {number} - 返回当前日期的时间戳。
+     *
+     * @example
+        const date = new ZDate('2024/02/01 23:59:59')
+        set.setWeek(7)
+     * // 输出 1707580800000
+     * @example
+        const date = new ZDate('2024/02/01 23:59:59')
+        set.setWeek(7, 1, 1)
+     * // 输出 1707667200000
+     */
+    setWeek(week: number, ...params: WeekParams): number;
+    /**
+     * 获取日期的周数。
+     * @param fromDay — 周的起始日，默认为星期日（0）。
+     * @param firstWeekDiff — 用于调整第一周的差异，默认为0。
+     * @returns {number} - 返回当前日期所属的周数，范围从 1 开始。
+     *
+     * @example new ZDate('2024/02/01 23:59:59').getWeek(1, 1)
+     * // 输出 5
+     * @example new ZDate('2024/02/01 23:59:59').getWeek(0, 1)
+     * // 输出 4
+     * @example new ZDate('2024/02/01 23:59:59').getWeek()
+     * // 输出 5
+     */
+    getWeek(...params: WeekParams): number;
+    /**
+     * 设置日期的 UTC 周数。
+     * @param {number} week - 周数，范围从 1 开始。
+     * @param fromDay — 周的起始日，默认为星期日（0）。
+     * @param firstWeekDiff — 用于调整第一周的差异，默认为0。
+     * @returns {number} - 返回当前日期的 UTC 时间戳。
+     */
+    setUTCWeek(week: number, ...params: WeekParams): number;
+    /**
+     * 获取日期的 UTC 周数。
+     * @param fromDay — 周的起始日，默认为星期日（0）。
+     * @param firstWeekDiff — 用于调整第一周的差异，默认为0。
+     * @returns {number} - 返回当前日期所属的 UTC 周数，范围从 1 开始。
+     */
+    getUTCWeek(...params: WeekParams): number;
+    /**
+     * 获取格式化后的日期字符串。
+     * @param format — 格式化字符串，默认为 'YYYY/MM/DD HH:mm:ss'。
+     * @param isUTC — 是否为UTC时间，默认为 false。
+     * @param fromDay — 可选参数，周的起始日，默认为星期日（0）。
+     * @param firstWeekDiff — 可选参数，用于调整第一周的差异，默认为0。
+     * @returns {string} - 返回格式化后的日期字符串。
+     *
+     * @example new ZDate('2024/01/01 00:00:00').getFormatStr('YYYY/MM/DD 23:59:59')
+     * // 输出 '2024/01/01 23:59:59'
+     */
+    getFormatStr(...params: WithoutFirstParams<typeof getFormatStr>): string;
+    /**
+     * 获取最小时间格式的日期字符串。
+     * @param dateUnit — 日期单位，排除毫秒。
+     * @param withMs — 是否包含毫秒，默认为 false。
+     * @param fromDay — 可选参数，周的起始日，默认为星期日（0）。
+     * @param firstWeekDiff — 可选参数，用于调整第一周的差异，默认为0。
+     * @returns {string} - 返回最小时间格式的日期字符串。
+     *
+     * @example new ZDate('2004/05/06 07:08:09').getMinTimeFormatStr('FullYear')
+     * // 输出 '2004/01/01 00:00:00'
+     * @example new ZDate('2004/05/06 07:08:09').getMinTimeFormatStr('FullYear', true)
+     * // 输出 '2004/01/01 00:00:00.000'
+     *
+     * @example new ZDate('2004/05/06 07:08:09').getMinTimeFormatStr('Quarter')
+     * // 输出 '2004/04/01 00:00:00'
+     * @example new ZDate('2004/05/06 07:08:09').getMinTimeFormatStr('Quarter', true)
+     * // 输出 '2004/04/01 00:00:00.000'
+     *
+     * @example new ZDate('2004/05/06 07:08:09').getMinTimeFormatStr('Month')
+     * // 输出 '2004/05/01 00:00:00'
+     * @example new ZDate('2004/05/06 07:08:09').getMinTimeFormatStr('Month', true)
+     * // 输出 '2004/05/01 00:00:00.000'
+     *
+     * @example new ZDate('2004/05/06 07:08:09').getMinTimeFormatStr('Date')
+     * // 输出 '2004/05/06 00:00:00'
+     * @example new ZDate('2004/05/06 07:08:09').getMinTimeFormatStr('Date', true)
+     * // 输出 '2004/05/06 00:00:00.000'
+     *
+     * @example new ZDate('2004/05/06 07:08:09').getMinTimeFormatStr('Hours')
+     * // 输出 '2004/05/06 07:00:00'
+     * @example new ZDate('2004/05/06 07:08:09').getMinTimeFormatStr('Hours', true)
+     * // 输出 '2004/05/06 07:00:00.000'
+     *
+     * @example new ZDate('2004/05/06 07:08:09').getMinTimeFormatStr('Minutes')
+     * // 输出 '2004/05/06 07:08:00'
+     * @example new ZDate('2004/05/06 07:08:09').getMinTimeFormatStr('Minutes', true)
+     * // 输出 '2004/05/06 07:08:00.000'
+     *
+     * @example new ZDate('2004/05/06 07:08:09').getMinTimeFormatStr('Seconds')
+     * // 输出 '2004/05/06 07:08:09'
+     * @example new ZDate('2004/05/06 07:08:09').getMinTimeFormatStr('Seconds', true)
+     * // 输出 '2004/05/06 07:08:09.000'
+     */
+    getMinTimeFormatStr(...params: WithoutFirstParams<typeof getMinTimeFormat>): string;
+    /**
+     * 获取最大时间格式的日期字符串。
+     * @param dateUnit — 日期单位，排除毫秒。
+     * @param withMs — 是否包含毫秒，默认为 false。
+     * @param fromDay — 可选参数，周的起始日，默认为星期日（0）。
+     * @param firstWeekDiff — 可选参数，用于调整第一周的差异，默认为0。
+     * @returns {string} - 返回最大时间格式的日期字符串。
+     *
+     * @example new ZDate('2004/05/06 07:08:09').getMaxTimeFormatStr('FullYear')
+     * // 输出 '2004/12/31 23:59:59'
+     * @example new ZDate('2004/05/06 07:08:09').getMaxTimeFormatStr('FullYear', true)
+     * // 输出 '2004/12/31 23:59:59.999'
+     *
+     * @example new ZDate('2004/05/06 07:08:09').getMaxTimeFormatStr('Quarter')
+     * // 输出 '2004/06/30 23:59:59'
+     * @example new ZDate('2004/05/06 07:08:09').getMaxTimeFormatStr('Quarter', true)
+     * // 输出 '2004/06/30 23:59:59.999'
+     *
+     * @example new ZDate('2004/05/06 07:08:09').getMaxTimeFormatStr('Month')
+     * // 输出 '2004/05/31 23:59:59'
+     * @example new ZDate('2004/05/06 07:08:09').getMaxTimeFormatStr('Month', true)
+     * // 输出 '2004/05/31 23:59:59.999'
+     *
+     * @example new ZDate('2004/05/06 07:08:09').getMaxTimeFormatStr('Date')
+     * // 输出 '2004/05/06 23:59:59'
+     * @example new ZDate('2004/05/06 07:08:09').getMaxTimeFormatStr('Date', true)
+     * // 输出 '2004/05/06 23:59:59.999'
+     *
+     * @example new ZDate('2004/05/06 07:08:09').getMaxTimeFormatStr('Hours')
+     * // 输出 '2004/05/06 07:59:59'
+     * @example new ZDate('2004/05/06 07:08:09').getMaxTimeFormatStr('Hours', true)
+     * // 输出 '2004/05/06 07:59:59.999'
+     *
+     * @example new ZDate('2004/05/06 07:08:09').getMaxTimeFormatStr('Minutes')
+     * // 输出 '2004/05/06 07:08:59'
+     * @example new ZDate('2004/05/06 07:08:09').getMaxTimeFormatStr('Minutes', true)
+     * // 输出 '2004/05/06 07:08:59.999'
+     *
+     * @example new ZDate('2004/05/06 07:08:09').getMaxTimeFormatStr('Seconds')
+     * // 输出 '2004/05/06 07:08:09'
+     * @example new ZDate('2004/05/06 07:08:09').getMaxTimeFormatStr('Seconds', true)
+     * // 输出 '2004/05/06 07:08:09.999'
+     */
+    getMaxTimeFormatStr(...params: WithoutFirstParams<typeof getMaxTimeFormat>): string;
+    /**
+     * 根据指定的格式设置日期。
+     * @param dateStr — 包含日期和时间的字符串。
+     * @param format — 格式化字符串。
+     * @param fromDay — 可选参数，周的起始日，默认为星期日（0）。
+     * @param firstWeekDiff — 可选参数，用于调整第一周的差异，默认为0。
+     * @returns {number} - 返回当前日期的时间戳。
+     *
+     * @example
+        const date = new ZDate('2024/01/01 00:00:00')
+        date.setByFormat('08/02 03:04', 'MM/DD HH:mm')
+     * // 输出 1722539071887
+     */
+    setByFormat(...args: WithoutFirstParams<typeof setDateByFormat>): number;
+}
+export {};

package/src/utils/DeclareType.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 定义一个类型别名 `ClassType`，表示一个构造函数类型，它可以接受任意数量的参数并返回任意类型的值。
+ */
+export type ClassType = new (...args: any) => any;
+/**
+ * 定义一个类型别名 `KeyMatch`，它是一个泛型类型，接受两个类型参数 `T` 和 `V`。
+ * 这个类型别名的目的是从类型 `T` 中找出所有属性值为 `V` 的属性名，并将这些属性名组成一个联合类型。
+ *
+ * @template T - 一个对象类型，用于查找属性。
+ * @template V - 一个类型，用于匹配属性值。
+ * @returns 返回一个联合类型，包含所有属性值为 `V` 的属性名。
+ */
+export type KeyMatch<T, V> = {
+    [K in keyof T]-?: T[K] extends V ? K : never;
+}[keyof T];
+/**
+ * 定义一个类型别名 `KeyValType`，它表示一个联合类型，包含字符串和数字类型。
+ * 这个类型别名通常用于表示键值对中的键或值的类型。
+ */
+export type KeyValType = string | number;
+/**
+ * 定义一个类型别名 `WithoutFirst`，它是一个泛型类型，接受一个数组类型 `T` 作为参数。
+ * 这个类型别名的目的是从数组 `T` 中移除第一个元素，并返回剩余元素组成的数组类型。
+ *
+ * @template T - 一个数组类型，用于移除第一个元素。
+ * @returns 返回一个数组类型，包含 `T` 中除第一个元素外的所有元素。
+ * 如果 `T` 是空数组，则返回 `never` 类型。
+ */
+export type WithoutFirst<T extends any[]> = T extends [any, ...infer R] ? R : never;
+/**
+ * 定义一个类型别名 `WithoutFirstParams`，它是一个泛型类型，接受一个函数类型 `T` 作为参数。
+ * 这个类型别名的目的是从函数 `T` 的参数列表中移除第一个参数，并返回剩余参数组成的数组类型。
+ *
+ * @template T - 一个函数类型，用于移除第一个参数。
+ * @returns 返回一个数组类型，包含 `T` 中除第一个参数外的所有参数。
+ * 如果 `T` 没有参数，则返回 `never` 类型。
+ */
+export type WithoutFirstParams<T extends (...args: any) => any> = WithoutFirst<Parameters<T>>;
+export {};

package/src/utils/class/bind.d.ts

@@ -0,0 +1,43 @@
+import { CombineClass, CombineInstanceType } from './combine';
+/**
+ * 一个基类，用于实现原型绑定的功能。
+ * 该类包含一个构造函数和两个静态方法：bindList 和 bindObject。
+ * @example
+    class A extends WithPrototype {}
+ */
+export declare class WithPrototype {
+    /**
+     * 构造函数，接收任意数量的参数。
+     * @param args - 传递给构造函数的参数。
+     */
+    constructor(...args: any);
+    /**
+     * 静态方法，用于将一个类的原型绑定到一个对象列表上。
+     * @param this - 当前类的引用。
+     * @param list - 要绑定原型的对象列表。
+     * @returns 一个新的对象列表，每个对象都绑定了当前类的原型。
+     */
+    static bindList<Class extends typeof WithPrototype & CombineClass>(this: Class, list: CombineInstanceType<Class>[]): CombineInstanceType<Class>[];
+    /**
+     * 静态方法，用于将一个类的原型绑定到一个对象上。
+     * @param this - 当前类的引用。
+     * @param data - 要绑定原型的对象。
+     * @returns 一个新的对象，绑定了当前类的原型。
+     */
+    static bindObject<Class extends typeof WithPrototype & CombineClass>(this: Class, data: CombineInstanceType<Class>): CombineInstanceType<Class>;
+}
+/**
+ * 一个继承自 WithPrototype 的类，用于实现使用 new 关键字创建对象时的原型绑定功能。
+ * 该类重写了 bindObject 方法，使用 new 关键字创建对象。
+ * @example
+    class A extends WithNew {}
+ */
+export declare class WithNew extends WithPrototype {
+    /**
+     * 静态方法，用于使用 new 关键字创建一个新的对象，并将当前类的原型绑定到该对象上。
+     * @param this - 当前类的引用。
+     * @param data - 传递给构造函数的参数。
+     * @returns 一个新的对象，绑定了当前类的原型。
+     */
+    static bindObject<Class extends typeof WithNew & CombineClass>(this: Class, data: CombineInstanceType<Class>): CombineInstanceType<Class>;
+}