@cloudcome/utils-core 1.1.1 → 1.2.0

package/src/date/relative.ts

@@ -1,92 +0,0 @@
-import { stringFormat } from '@/string';
-import { isArray } from '@/type';
-import { type TDateValue, dateFormat, dateParse } from './core';
-
-export type TDateRelativeTemplate = [
-  number /*单位时间差，为 0 表示不计算单位差值，单位秒*/,
-  number /*最大时间差，单位：秒*/,
-  string /*过去模板字符串，%d 表述单位差值*/,
-  string? /*将来模板字符串，%d 表述单位差值，可选*/,
-];
-export type TDateRelativeTemplates = TDateRelativeTemplate[];
-
-const defaultDiffTemplates: TDateRelativeTemplates = [
-  [0, 10, '刚刚'],
-  [1, 60, '{n} 秒前', '{n} 秒后'],
-  [60, 60 * 60, '{n} 分钟前', '{n} 分钟后'],
-  [60 * 60, 60 * 60 * 24, '{n} 小时前', '{n} 小时后'],
-  [0, 60 * 60 * 24 * 2, '昨天', '明天'],
-  [0, 60 * 60 * 24 * 3, '前天', '后天'],
-  [60 * 60 * 24, 60 * 60 * 24 * 30, '{n} 天前', '{n} 天后'],
-  [0, Number.POSITIVE_INFINITY, 'YYYY年MM月DD日'],
-];
-
-/**
- * 相对时间
- * @param {TDateValue} dateValue 比较的时间
- * @param {TDateValue} [refDateValue] 相对的时间，默认为当前
- * @param {TDateRelativeTemplates} [templates] 模板
- * @returns {string} 格式化后的相对时间字符串
- * @example
- * ```typescript
- * // 默认模板
- * dateRelative(new Date('2023-01-01')); // '刚刚'
- * dateRelative(new Date('2023-01-01'), new Date('2023-01-02')); // '昨天'
- * dateRelative(new Date('2023-01-01'), new Date('2023-01-04')); // '3 天前'
- * dateRelative(new Date('2023-01-01'), new Date('2023-02-01')); // '2023年01月01日'
- * ```
- * @example
- * ```typescript
- * // 自定义模板
- * const templates: DateRelativeTemplates = [
- *   [0, 10, '刚刚'],
- *   [1, 60, '{n} 秒前', '{n} 秒后'],
- *   [60, 60 * 60, '{n} 分钟前', '{n} 分钟后'],
- *   [60 * 60, 60 * 60 * 24, '{n} 小时前', '{n} 小时后'],
- *   [0, 60 * 60 * 24 * 2, '昨天', '明天'],
- *   [0, 60 * 60 * 24 * 3, '前天', '后天'],
- *   [60 * 60 * 24, 60 * 60 * 24 * 30, '{n} 天前', '{n} 天后'],
- *   [0, Number.POSITIVE_INFINITY, 'YYYY年MM月DD日'],
- * ];
- * dateRelative(new Date('2023-01-01'), new Date('2023-01-02'), templates); // '昨天'
- * dateRelative(new Date('2023-01-01'), new Date('2023-01-04'), templates); // '3 天前'
- * dateRelative(new Date('2023-01-01'), new Date('2023-02-01'), templates); // '2023年01月01日'
- * ```
- */
-export function dateRelative(
-  dateValue: TDateValue,
-  refDateValue: TDateValue,
-  templates: TDateRelativeTemplates,
-): string;
-export function dateRelative(dateValue: TDateValue, refDateValue: TDateValue): string;
-export function dateRelative(dateValue: TDateValue, templates: TDateRelativeTemplates): string;
-export function dateRelative(dateValue: TDateValue): string;
-export function dateRelative(
-  dateValue: TDateValue,
-  refDateValue?: TDateValue | TDateRelativeTemplates,
-  templates?: TDateRelativeTemplates,
-): string {
-  const now = Date.now();
-  const refDateValueFinal = isArray(refDateValue) ? now : refDateValue || now;
-  const templatesFinal = isArray(templates) ? templates : isArray(refDateValue) ? refDateValue : defaultDiffTemplates;
-  const d1 = dateParse(dateValue);
-  const d2 = dateParse(refDateValueFinal);
-  const diff = d1.getTime() - d2.getTime();
-  const isAgo = diff < 0;
-  const absDiff = Math.abs(diff);
-  let relative = '';
-
-  for (const [base, max, agoTemplate, featureTemplate] of templatesFinal) {
-    const unitFinal = base * 1000;
-    const maxFinal = max * 1000;
-
-    if (absDiff < maxFinal) {
-      const template = isAgo ? agoTemplate : featureTemplate || agoTemplate;
-      const length = unitFinal === 0 ? 0 : Math.max(Math.floor(absDiff / unitFinal), 1);
-      relative = unitFinal === 0 ? dateFormat(dateValue, template) : stringFormat(template, { n: length });
-      break;
-    }
-  }
-
-  return relative;
-}

package/src/date/start-end.ts

@@ -1,246 +0,0 @@
-import { type TDateLike, type TDateValue, dateParse } from './core';
-
-/**
- * 时间单位符号枚举
- * - 'Y': 年
- * - 'M': 月
- * - 'D': 天
- * - 'W': 周
- * - 'h': 小时
- * - 'm': 分钟
- * - 's': 秒
- */
-type _TDateOfSymbol = 'Y' | 'M' | 'D' | 'W' | 'h' | 'm' | 's';
-
-/**
- * 各时间单位起始时间映射表
- * 包含将日期设置到单位起始时间的函数
- */
-const dateOfStartMap: [_TDateOfSymbol, (date: TDateLike) => unknown][] = [
-  ['s', (d) => d.setMilliseconds(0)],
-  ['m', (d) => d.setSeconds(0)],
-  ['h', (d) => d.setMinutes(0)],
-  ['D', (d) => d.setHours(0)],
-  ['W', (d) => d.setHours(0)],
-  ['M', (d) => d.setDate(1)],
-  ['Y', (d) => d.setMonth(0)],
-];
-
-/**
- * 返回指定时间单位的起始时间
- * @param dateValue - 可以是数值、字符串或 Date 对象
- * @param symbol - 时间单位符号，可选值为 'Y'（年）、'M'（月）、'D'（天）、'h'（小时）、'm'（分钟）、's'（秒），默认为 'D'
- * @returns 返回指定时间单位的起始时间
- * @example
- * ```typescript
- * const date = new Date(2023, 5, 15, 12, 30, 45, 500); // 2023-06-15 12:30:45.500
- *
- * // 返回秒级起始时间
- * dateOfStart(date, 's'); // 2023-06-15 12:30:45.000
- *
- * // 返回分钟级起始时间
- * dateOfStart(date, 'm'); // 2023-06-15 12:30:00.000
- *
- * // 返回小时级起始时间
- * dateOfStart(date, 'h'); // 2023-06-15 12:00:00.000
- *
- * // 返回天级起始时间
- * dateOfStart(date, 'D'); // 2023-06-15 00:00:00.000
- *
- * // 返回月级起始时间
- * dateOfStart(date, 'M'); // 2023-06-01 00:00:00.000
- *
- * // 返回年级起始时间
- * dateOfStart(date, 'Y'); // 2023-01-01 00:00:00.000
- *
- * // 默认返回天级起始时间
- * dateOfStart(date); // 2023-06-15 00:00:00.000
- * ```
- */
-function _dateStart(dateValue: TDateValue, symbol: _TDateOfSymbol = 'D') {
-  const date = dateParse(dateValue);
-
-  for (const [sym, fn] of dateOfStartMap) {
-    fn(date);
-    if (symbol === sym) break;
-  }
-
-  return date;
-}
-
-/**
- * 返回秒级起始时间
- * @param dateValue - 可以是数值、字符串或 Date 对象
- * @returns 返回秒级起始时间，毫秒部分为 0
- */
-export function dateStartInSecond(dateValue: TDateValue) {
-  return _dateStart(dateValue, 's');
-}
-
-/**
- * 返回分钟级起始时间
- * @param dateValue - 可以是数值、字符串或 Date 对象
- * @returns 返回分钟级起始时间，秒和毫秒部分为 0
- */
-export function dateStartInMinute(dateValue: TDateValue) {
-  return _dateStart(dateValue, 'm');
-}
-
-/**
- * 返回小时级起始时间
- * @param dateValue - 可以是数值、字符串或 Date 对象
- * @returns 返回小时级起始时间，分钟、秒和毫秒部分为 0
- */
-export function dateStartInHour(dateValue: TDateValue) {
-  return _dateStart(dateValue, 'h');
-}
-
-/**
- * 返回天级起始时间
- * @param dateValue - 可以是数值、字符串或 Date 对象
- * @returns 返回天级起始时间，小时、分钟、秒和毫秒部分为 0
- */
-export function dateStartInDay(dateValue: TDateValue) {
-  return _dateStart(dateValue, 'D');
-}
-
-/**
- * 返回月级起始时间
- * @param dateValue - 可以是数值、字符串或 Date 对象
- * @returns 返回月级起始时间，日期为当月第一天，时间部分为 0
- */
-export function dateStartInMonth(dateValue: TDateValue) {
-  return _dateStart(dateValue, 'M');
-}
-
-/**
- * 返回年级起始时间
- * @param dateValue - 可以是数值、字符串或 Date 对象
- * @returns 返回年级起始时间，月份为 1 月，日期为 1 日，时间部分为 0
- */
-export function dateStartInYear(dateValue: TDateValue) {
-  return _dateStart(dateValue, 'Y');
-}
-
-/**
- * 各时间单位结束时间映射表
- * 包含将日期设置到单位结束时间的函数
- */
-const dateOfEndMap: [_TDateOfSymbol, (date: TDateLike) => unknown][] = [
-  ['s', (d) => d.setMilliseconds(999)],
-  ['m', (d) => d.setSeconds(59)],
-  ['h', (d) => d.setMinutes(59)],
-  ['D', (d) => d.setHours(23)],
-  [
-    'M',
-    (d) => {
-      const d2 = dateParse(d);
-      d2.setMonth(d.getMonth() + 1);
-      d2.setDate(0);
-      d.setDate(d2.getDate());
-    },
-  ],
-  [
-    'Y',
-    (d) => {
-      d.setMonth(11);
-      d.setDate(31);
-    },
-  ],
-];
-
-/**
- * 返回指定时间单位的结束时间
- * @param dateValue - 可以是数值、字符串或 Date 对象
- * @param symbol - 时间单位符号，可选值为 'Y'（年）、'M'（月）、'D'（天）、'h'（小时）、'm'（分钟）、's'（秒），默认为 'D'
- * @returns 返回指定时间单位的结束时间
- * @example
- * ```typescript
- * const date = new Date(2023, 5, 15, 12, 30, 45, 500); // 2023-06-15 12:30:45.500
- *
- * // 返回秒级结束时间
- * dateOfEnd(date, 's'); // 2023-06-15 12:30:45.999
- *
- * // 返回分钟级结束时间
- * dateOfEnd(date, 'm'); // 2023-06-15 12:30:59.999
- *
- * // 返回小时级结束时间
- * dateOfEnd(date, 'h'); // 2023-06-15 12:59:59.999
- *
- * // 返回天级结束时间
- * dateOfEnd(date, 'D'); // 2023-06-15 23:59:59.999
- *
- * // 返回月级结束时间
- * dateOfEnd(date, 'M'); // 2023-06-30 23:59:59.999
- *
- * // 返回年级结束时间
- * dateOfEnd(date, 'Y'); // 2023-12-31 23:59:59.999
- *
- * // 默认返回天级结束时间
- * dateOfEnd(date); // 2023-06-15 23:59:59.999
- * ```
- */
-function _dateEnd(dateValue: TDateValue, symbol: _TDateOfSymbol = 'D') {
-  const date = dateParse(dateValue);
-
-  for (const [sym, fn] of dateOfEndMap) {
-    fn(date);
-    if (symbol === sym) break;
-  }
-
-  return date;
-}
-
-/**
- * 返回秒级结束时间
- * @param dateValue - 可以是数值、字符串或 Date 对象
- * @returns 返回秒级结束时间，毫秒部分为 999
- */
-export function dateEndInSecond(dateValue: TDateValue) {
-  return _dateEnd(dateValue, 's');
-}
-
-/**
- * 返回分钟级结束时间
- * @param dateValue - 可以是数值、字符串或 Date 对象
- * @returns 返回分钟级结束时间，秒为 59，毫秒为 999
- */
-export function dateEndInMinute(dateValue: TDateValue) {
-  return _dateEnd(dateValue, 'm');
-}
-
-/**
- * 返回小时级结束时间
- * @param dateValue - 可以是数值、字符串或 Date 对象
- * @returns 返回小时级结束时间，分钟为 59，秒为 59，毫秒为 999
- */
-export function dateEndInHour(dateValue: TDateValue) {
-  return _dateEnd(dateValue, 'h');
-}
-
-/**
- * 返回天级结束时间
- * @param dateValue - 可以是数值、字符串或 Date 对象
- * @returns 返回天级结束时间，小时为 23，分钟为 59，秒为 59，毫秒为 999
- */
-export function dateEndInDay(dateValue: TDateValue) {
-  return _dateEnd(dateValue, 'D');
-}
-
-/**
- * 返回月级结束时间
- * @param dateValue - 可以是数值、字符串或 Date 对象
- * @returns 返回月级结束时间，日期为当月最后一天，时间为 23:59:59.999
- */
-export function dateEndInMonth(dateValue: TDateValue) {
-  return _dateEnd(dateValue, 'M');
-}
-
-/**
- * 返回年级结束时间
- * @param dateValue - 可以是数值、字符串或 Date 对象
- * @returns 返回年级结束时间，月份为 12 月，日期为 31 日，时间为 23:59:59.999
- */
-export function dateEndInYear(dateValue: TDateValue) {
-  return _dateEnd(dateValue, 'Y');
-}

package/src/date/timezone.ts

@@ -1,220 +0,0 @@
-import { isNumber } from '../type';
-import { dateFormat } from './core';
-
-export type TTzDateOptions = {
-  /**
-   * 时间戳
-   * @default Date.now()
-   */
-  timestamp?: number;
-
-  /**
-   * 日期值
-   */
-  value?: readonly [
-    year?: number,
-    month?: number,
-    day?: number,
-    hours?: number,
-    minutes?: number,
-    seconds?: number,
-    milliseconds?: number,
-  ];
-
-  /**
-   * 时区偏移量，单位为分钟，默认为当前时区
-   */
-  offset?: number;
-};
-
-const TZ_OFFSET_MS = 60 * 1000;
-
-export class TzDate {
-  #timestamp: number;
-  #targetDate: Date;
-  #utcDate: Date;
-
-  #localTZOffset = TzDate.getOffset();
-  #localTzOffsetMS = this.#localTZOffset * TZ_OFFSET_MS;
-
-  #targetTzOffset = 0;
-  #targetTzOffsetMS = 0;
-
-  #options: TTzDateOptions;
-
-  constructor(options?: TTzDateOptions | TzDate) {
-    this.#options = (options instanceof TzDate ? options.#options : options) || {};
-    const { offset, timestamp, value } = this.#options;
-    this.#targetTzOffset = isNumber(offset) ? offset : this.#localTZOffset;
-    this.#targetTzOffsetMS = this.#targetTzOffset * TZ_OFFSET_MS;
-
-    if (Array.isArray(value) && value.length > 0) {
-      const [fullYear, month, day, hours, minutes, seconds, milliseconds] = value;
-      const timestamp = Date.UTC(
-        fullYear ?? 0,
-        month ?? 0,
-        day ?? 1,
-        hours ?? 0,
-        minutes ?? 0,
-        seconds ?? 0,
-        milliseconds ?? 0,
-      );
-
-      this.#timestamp = timestamp + this.#targetTzOffsetMS;
-    } else {
-      this.#timestamp = timestamp || Date.now();
-    }
-
-    this.#targetDate = new Date(this.#timestamp + this.#localTzOffsetMS - this.#targetTzOffsetMS);
-    this.#utcDate = new Date(this.#timestamp + this.#localTzOffsetMS);
-  }
-
-  #updateTimestamp() {
-    this.#timestamp = this.#targetDate.getTime() + this.#targetTzOffsetMS - this.#localTzOffsetMS;
-    this.#utcDate = new Date(this.#timestamp + this.#localTzOffsetMS);
-  }
-
-  getTimezoneOffset() {
-    return this.#targetTzOffset;
-  }
-
-  getTimezoneOrder() {
-    return TzDate.getOrder(this.#targetTzOffset);
-  }
-
-  getFullYear() {
-    return this.#targetDate.getFullYear();
-  }
-
-  getMonth() {
-    return this.#targetDate.getMonth();
-  }
-
-  getDate() {
-    return this.#targetDate.getDate();
-  }
-
-  getHours() {
-    return this.#targetDate.getHours();
-  }
-
-  getMinutes() {
-    return this.#targetDate.getMinutes();
-  }
-
-  getSeconds() {
-    return this.#targetDate.getSeconds();
-  }
-
-  getMilliseconds() {
-    return this.#targetDate.getMilliseconds();
-  }
-
-  setFullYear(year: number, month?: number, date?: number) {
-    this.#targetDate.setFullYear(year);
-    this.#updateTimestamp();
-
-    if (isNumber(month)) this.setMonth(month);
-    if (isNumber(date)) this.setDate(date);
-
-    return this.getTime();
-  }
-
-  setMonth(month: number, date?: number) {
-    this.#targetDate.setMonth(month);
-    this.#updateTimestamp();
-
-    if (isNumber(date)) this.setDate(date);
-
-    return this.getTime();
-  }
-
-  setDate(date: number) {
-    this.#targetDate.setDate(date);
-    this.#updateTimestamp();
-
-    return this.getTime();
-  }
-
-  setHours(hours: number, minutes?: number, seconds?: number, milliseconds?: number) {
-    this.#targetDate.setHours(hours);
-    this.#updateTimestamp();
-
-    if (isNumber(minutes)) this.setMinutes(minutes);
-    if (isNumber(seconds)) this.setSeconds(seconds);
-    if (isNumber(milliseconds)) this.setMilliseconds(milliseconds);
-
-    return this.getTime();
-  }
-
-  setMinutes(minutes: number, seconds?: number, milliseconds?: number) {
-    this.#targetDate.setMinutes(minutes);
-    this.#updateTimestamp();
-
-    if (isNumber(seconds)) this.setSeconds(seconds);
-    if (isNumber(milliseconds)) this.setMilliseconds(milliseconds);
-
-    return this.getTime();
-  }
-
-  setSeconds(seconds: number, milliseconds?: number) {
-    this.#targetDate.setSeconds(seconds);
-    this.#updateTimestamp();
-
-    if (isNumber(milliseconds)) this.setMilliseconds(milliseconds);
-
-    return this.getTime();
-  }
-
-  setMilliseconds(milliseconds: number) {
-    this.#targetDate.setMilliseconds(milliseconds);
-    this.#updateTimestamp();
-
-    return this.getTime();
-  }
-
-  getTime() {
-    return this.#timestamp;
-  }
-
-  getDay() {
-    return this.#targetDate.getDay();
-  }
-
-  toISOString() {
-    return dateFormat(this.#utcDate, 'YYYY-MM-DDTHH:mm:ss.SSSZ');
-  }
-
-  /**
-   * 创建一个 TzDate 对象
-   * @param td - 需要转换的日期对象
-   * @param offset - 目标时区分钟偏移量，默认为当前时区
-   * @returns 返回一个 TzDate 对象
-   * @example
-   * ```js
-   * const tzDate = TzDate.from(new TzDate());
-   * ```
-   */
-  static from(td: TzDate, offset = TzDate.getOffset()) {
-    return new TzDate({
-      offset: offset,
-      timestamp: td.getTime(),
-    });
-  }
-
-  /**
-   * 获取时区序号
-   * @param offset - 默认使用当前时区分钟偏移量
-   */
-  static getOrder(offset = TzDate.getOffset()) {
-    return offset / -60;
-  }
-
-  /**
-   * 获取时区分钟偏移量
-   * @param gmtOrder - 默认使用当前时区序号
-   */
-  static getOffset(gmtOrder?: number) {
-    return isNumber(gmtOrder) ? gmtOrder * -60 : new Date().getTimezoneOffset();
-  }
-}

package/src/date/weeks.ts

@@ -1,100 +0,0 @@
-import { DATE_DAY_MS } from './const';
-import { type TDateValue, dateParse } from './core';
-
-export enum EWeekStart {
-  /**
-   * 周日作为一周的起始日
-   */
-  sunday = 0,
-  /**
-   * 周一作为一周的起始日
-   */
-  monday = 1,
-  /**
-   * 周二作为一周的起始日
-   */
-  tuesday = 2,
-  /**
-   * 周三作为一周的起始日
-   */
-  wednesday = 3,
-  /**
-   * 周四作为一周的起始日
-   */
-  thursday = 4,
-  /**
-   * 周五作为一周的起始日
-   */
-  friday = 5,
-  /**
-   * 周六作为一周的起始日
-   */
-  saturday = 6,
-  // /**
-  //  * 1号所在的周为第一周
-  //  */
-  // firstDate = 7,
-  // /**
-  //  * 完整7天表示第一周
-  //  */
-  // firstFullWeek = 8,
-}
-
-/**
- * 计算指定日期所在年份或月份的周数
- * @param dateValue - 可以是数值、字符串或 Date 对象
- * @param type - 计算范围，'Y' 表示年份，'M' 表示月份
- * @param weekStart - 一周的起始日，默认为 0（周日）
- * @returns 返回指定日期所在年份或月份的周数
- * @example
- * ```typescript
- * const date = new Date(2023, 0, 1); // 2023-01-01
- * _dateWeeks(date, 'Y'); // 1 (计算年份的周数)
- * _dateWeeks(date, 'M'); // 1 (计算月份的周数)
- * _dateWeeks(date, 'Y', 1); // 1 (周一作为一周的起始日，计算年份的周数)
- * ```
- */
-export function _dateWeeks(dateValue: TDateValue, type: 'Y' | 'M', weekStart: EWeekStart = 0) {
-  const date = dateParse(dateValue);
-
-  const year = date.getFullYear();
-  const month = date.getMonth();
-
-  const firstDate = type === 'Y' ? new Date(year, 0, 1) : new Date(year, month, 1);
-  const firstWeek = firstDate.getDay();
-  const days = Math.ceil((date.getTime() - firstDate.getTime()) / DATE_DAY_MS);
-
-  return Math.ceil((firstWeek + days - weekStart) / 7);
-}
-
-/**
- * 计算指定日期所在年份的周数
- * @param dateValue - 可以是数值、字符串或 Date 对象
- * @param weekStart - 一周的起始日，默认为 0（周日）
- * @returns 返回指定日期所在年份的周数
- * @example
- * ```typescript
- * const date = new Date(2023, 0, 1); // 2023-01-01
- * weeksOfYear(date); // 1
- * weeksOfYear(date, 1); // 1 (周一作为一周的起始日)
- * ```
- */
-export function weeksOfYear(dateValue: TDateValue, weekStart: EWeekStart = 0) {
-  return _dateWeeks(dateValue, 'Y', weekStart);
-}
-
-/**
- * 计算指定日期所在月份的周数
- * @param dateValue - 可以是数值、字符串或 Date 对象
- * @param weekStart - 一周的起始日，默认为 0（周日）
- * @returns 返回指定日期所在月份的周数
- * @example
- * ```typescript
- * const date = new Date(2023, 0, 1); // 2023-01-01
- * weeksOfMonth(date); // 1
- * weeksOfMonth(date, 1); // 1 (周一作为一周的起始日)
- * ```
- */
-export function weeksOfMonth(dateValue: TDateValue, weekStart: EWeekStart = 0) {
-  return _dateWeeks(dateValue, 'M', weekStart);
-}

package/src/dts/global.d.ts

@@ -1,27 +0,0 @@
-/**
- * @file global.d.ts
- */
-
-/**
- * package.json name
- */
-declare const PKG_NAME: string;
-
-/**
- * package.json version
- */
-declare const PKG_VERSION: string;
-
-/**
- * package.json description
- */
-declare const PKG_DESCRIPTION: string;
-
-declare const IS_TEST: string;
-
-interface TEST_MOCK {
-  IS_BROWSER: boolean;
-  IS_NODE: boolean;
-}
-
-declare const TEST_MOCK: TEST_MOCK;