@sybz-components/utils 0.0.12 → 1.0.1

package/dist/day.d.mts

@@ -1,81 +0,0 @@
-import { ConfigType, QUnitType, OpUnitType } from 'dayjs';
-
-type DayUnit = QUnitType | OpUnitType;
-/**
- * 使用 `dayjs` 格式化日期。
- *
- * @param date 要格式化的日期值。为空时默认使用当前时间。
- * @param format 输出格式，默认 `YYYY-MM-DD HH:mm:ss`。
- * @returns 格式化后的日期字符串。
- *
- * @example
- * formatDate('2026-04-24 12:30:45')
- * // => '2026-04-24 12:30:45'
- *
- * @example
- * formatDate('2026-04-24 12:30:45', 'YYYY/MM/DD')
- * // => '2026/04/24'
- */
-declare function formatDate(date?: ConfigType, format?: string): string;
-/**
- * 将日期格式化为 `YYYY-MM-DD`。
- *
- * @param date 要格式化的日期值。
- * @returns 形如 `2026-04-24` 的字符串。
- *
- * @example
- * formatDateToDay(new Date())
- *
- * @example
- * formatDateToDay('2026-04-24 12:30:45')
- * // => '2026-04-24'
- */
-declare const formatDateToDay: (date: ConfigType) => string;
-/**
- * 将日期格式化为 `YYYY-MM-DD HH:mm`。
- *
- * @param date 要格式化的日期值。
- * @returns 形如 `2026-04-24 12:30` 的字符串。
- *
- * @example
- * formatDateToMinute(new Date())
- *
- * @example
- * formatDateToMinute('2026-04-24 12:30:45')
- * // => '2026-04-24 12:30'
- */
-declare const formatDateToMinute: (date: ConfigType) => string;
-/**
- * 计算两个日期之间的差值。
- *
- * @param date1 起始时间。未传时返回 `undefined`。
- * @param date2 对比时间，默认取当前时间。
- * @param format 差值单位，默认 `second`。
- * @returns 两个时间的差值。
- *
- * @example
- * diffDate('2026-04-24 12:00:00', '2026-04-24 11:59:00')
- * // => 60
- *
- * @example
- * diffDate('2026-04-24 12:00:00', '2026-04-24 11:30:00', 'minute')
- * // => 30
- */
-declare function diffDate(date1: ConfigType, date2?: ConfigType, format?: DayUnit): number | undefined;
-/**
- * 将秒数转换成“几秒前 / 几分钟前 / 几小时前 / 几天前”这类相对时间文案。
- *
- * @param second 距离当前时间的秒数。
- * @returns 中文相对时间描述。
- *
- * @example
- * diffDateFromCurrent(45)
- * // => '45秒前'
- *
- * @example
- * diffDateFromCurrent(3600)
- * // => '1小时前'
- */
-declare function diffDateFromCurrent(second: number): string;
-
-export { diffDate, diffDateFromCurrent, formatDate, formatDateToDay, formatDateToMinute };

package/dist/day.d.ts

@@ -1,81 +0,0 @@
-import { ConfigType, QUnitType, OpUnitType } from 'dayjs';
-
-type DayUnit = QUnitType | OpUnitType;
-/**
- * 使用 `dayjs` 格式化日期。
- *
- * @param date 要格式化的日期值。为空时默认使用当前时间。
- * @param format 输出格式，默认 `YYYY-MM-DD HH:mm:ss`。
- * @returns 格式化后的日期字符串。
- *
- * @example
- * formatDate('2026-04-24 12:30:45')
- * // => '2026-04-24 12:30:45'
- *
- * @example
- * formatDate('2026-04-24 12:30:45', 'YYYY/MM/DD')
- * // => '2026/04/24'
- */
-declare function formatDate(date?: ConfigType, format?: string): string;
-/**
- * 将日期格式化为 `YYYY-MM-DD`。
- *
- * @param date 要格式化的日期值。
- * @returns 形如 `2026-04-24` 的字符串。
- *
- * @example
- * formatDateToDay(new Date())
- *
- * @example
- * formatDateToDay('2026-04-24 12:30:45')
- * // => '2026-04-24'
- */
-declare const formatDateToDay: (date: ConfigType) => string;
-/**
- * 将日期格式化为 `YYYY-MM-DD HH:mm`。
- *
- * @param date 要格式化的日期值。
- * @returns 形如 `2026-04-24 12:30` 的字符串。
- *
- * @example
- * formatDateToMinute(new Date())
- *
- * @example
- * formatDateToMinute('2026-04-24 12:30:45')
- * // => '2026-04-24 12:30'
- */
-declare const formatDateToMinute: (date: ConfigType) => string;
-/**
- * 计算两个日期之间的差值。
- *
- * @param date1 起始时间。未传时返回 `undefined`。
- * @param date2 对比时间，默认取当前时间。
- * @param format 差值单位，默认 `second`。
- * @returns 两个时间的差值。
- *
- * @example
- * diffDate('2026-04-24 12:00:00', '2026-04-24 11:59:00')
- * // => 60
- *
- * @example
- * diffDate('2026-04-24 12:00:00', '2026-04-24 11:30:00', 'minute')
- * // => 30
- */
-declare function diffDate(date1: ConfigType, date2?: ConfigType, format?: DayUnit): number | undefined;
-/**
- * 将秒数转换成“几秒前 / 几分钟前 / 几小时前 / 几天前”这类相对时间文案。
- *
- * @param second 距离当前时间的秒数。
- * @returns 中文相对时间描述。
- *
- * @example
- * diffDateFromCurrent(45)
- * // => '45秒前'
- *
- * @example
- * diffDateFromCurrent(3600)
- * // => '1小时前'
- */
-declare function diffDateFromCurrent(second: number): string;
-
-export { diffDate, diffDateFromCurrent, formatDate, formatDateToDay, formatDateToMinute };

package/dist/day.mjs

@@ -1,31 +0,0 @@
-import dayjs from 'dayjs';
-
-function formatDate(date, format = "YYYY-MM-DD HH:mm:ss") {
-  return dayjs(date || /* @__PURE__ */ new Date()).format(format);
-}
-const formatDateToDay = (date) => formatDate(date, "YYYY-MM-DD");
-const formatDateToMinute = (date) => formatDate(date, "YYYY-MM-DD HH:mm");
-function diffDate(date1, date2 = dayjs(), format = "second") {
-  if (!date1) return;
-  return dayjs(date1).diff(dayjs(date2), format);
-}
-function diffDateFromCurrent(second) {
-  if (second >= 60 * 60 * 24 * 365) {
-    return `${parseInt(String(second / (60 * 60 * 24 * 365)))}\u5E74\u524D`;
-  }
-  if (second >= 60 * 60 * 24 * 30) {
-    return `${parseInt(String(second / (60 * 60 * 24 * 30)))}\u6708\u524D`;
-  }
-  if (second >= 60 * 60 * 24) {
-    return `${parseInt(String(second / (60 * 60 * 24)))}\u5929\u524D`;
-  }
-  if (second >= 60 * 60) {
-    return `${parseInt(String(second / (60 * 60)))}\u5C0F\u65F6\u524D`;
-  }
-  if (second >= 60) {
-    return `${parseInt(String(second / 60))}\u5206\u949F\u524D`;
-  }
-  return `${parseInt(String(second))}\u79D2\u524D`;
-}
-
-export { diffDate, diffDateFromCurrent, formatDate, formatDateToDay, formatDateToMinute };

package/dist/ws.cjs

@@ -1,175 +0,0 @@
-'use strict';
-
-const qs = require('qs');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
-
-const qs__default = /*#__PURE__*/_interopDefaultCompat(qs);
-
-const reconnectMaxCount = 3;
-const message = "ping";
-const interval = 3e3;
-const timeout = 1e3;
-class WS {
-  url;
-  socket = null;
-  reconnectCount = 0;
-  delay = null;
-  timer = null;
-  autoReconnect;
-  heartbeat;
-  query;
-  /**
-   * 创建并立即连接一个 WebSocket 实例。
-   *
-   * @param url WebSocket 地址，例如 `wss://example.com/ws`。
-   * @param options 连接配置，支持重连、心跳和 query 参数。
-   *
-   * @example
-   * const ws = new WS('wss://example.com/ws', {
-   *   autoReconnect: { reconnectMaxCount: 5 },
-   *   heartbeat: { message: 'ping', interval: 5000 },
-   *   query: { token: 'abc123' },
-   * })
-   */
-  constructor(url, options) {
-    const { autoReconnect = true, query = {}, heartbeat = false } = options || {};
-    this.autoReconnect = autoReconnect;
-    this.heartbeat = heartbeat;
-    this.query = query;
-    this.url = `${url}` + qs__default.stringify({ ...this.query }, { addQueryPrefix: true });
-    this.connect();
-  }
-  /**
-   * 主动发起连接。
-   *
-   * 调用时会先关闭旧连接，再创建新的 WebSocket 实例。
-   *
-   * @example
-   * const ws = new WS('wss://example.com/ws')
-   * ws.connect()
-   */
-  connect() {
-    this.close();
-    this.socket = new WebSocket(this.url);
-    this.onError();
-    this.onOpen();
-  }
-  /**
-   * 注册连接成功后的处理逻辑，并在需要时开启心跳。
-   *
-   * @example
-   * const ws = new WS('wss://example.com/ws')
-   * ws.onOpen()
-   */
-  onOpen() {
-    if (this.socket) {
-      this.socket.onopen = () => {
-        this.send("ping");
-        this.heartbeat && this.startHeartbeat();
-      };
-    }
-  }
-  /**
-   * 开启心跳发送。
-   *
-   * @example
-   * const ws = new WS('wss://example.com/ws', {
-   *   heartbeat: { message: 'ping', interval: 3000 },
-   * })
-   * ws.startHeartbeat()
-   */
-  startHeartbeat() {
-    const msg = this.heartbeat?.message || message;
-    const int = this.heartbeat?.interval || interval;
-    this.timer = setInterval(() => {
-      this.send(msg);
-    }, int);
-  }
-  /**
-   * 注册错误处理和自动重连逻辑。
-   *
-   * @example
-   * const ws = new WS('wss://example.com/ws', { autoReconnect: true })
-   * ws.onError()
-   */
-  onError() {
-    if (this.socket) {
-      this.socket.onerror = () => {
-        const count = this.autoReconnect?.reconnectMaxCount || reconnectMaxCount;
-        if (this.autoReconnect && this.reconnectCount < count) {
-          this.reconnectCount++;
-          this.connect();
-        }
-      };
-    }
-  }
-  /**
-   * 关闭连接并清理相关定时器。
-   *
-   * @example
-   * ws.close()
-   */
-  close() {
-    this.socket && this.socket.close();
-    this.delay && clearTimeout(this.delay);
-    this.timer && clearInterval(this.timer);
-    this.socket = null;
-  }
-  /**
-   * 监听服务端消息。
-   *
-   * 内部会优先尝试将消息解析为 JSON；解析失败时会回传原始 `MessageEvent`。
-   *
-   * @param callback 接收到消息时触发的回调。
-   *
-   * @example
-   * ws.onMessage((message) => {
-   *   console.log(message)
-   * })
-   */
-  onMessage(callback) {
-    if (this.socket) {
-      this.socket.onmessage = (data) => {
-        try {
-          const res = JSON.parse(data.data);
-          callback(res);
-        } catch {
-          callback(data);
-        }
-      };
-    }
-  }
-  /**
-   * 发送消息。
-   *
-   * - 如果连接已就绪，会立即发送
-   * - 如果正在连接，会延迟发送
-   * - 如果连接已关闭，会先重新连接再发送
-   *
-   * @param data 需要发送的消息内容。
-   *
-   * @example
-   * ws.send('hello')
-   *
-   * @example
-   * ws.send(JSON.stringify({ type: 'ping' }))
-   */
-  send(data) {
-    if (!this.socket) return;
-    if (this.socket.readyState === this.socket.OPEN) {
-      this.socket.send(JSON.stringify(data));
-    } else if (this.socket.readyState === this.socket.CONNECTING) {
-      this.delay = setTimeout(() => {
-        this.socket?.send(data);
-      }, timeout);
-    } else {
-      this.connect();
-      this.delay = setTimeout(() => {
-        this.socket?.send(data);
-      }, timeout);
-    }
-  }
-}
-
-exports.WS = WS;

package/dist/ws.d.cts

@@ -1,165 +0,0 @@
-type Timeout = ReturnType<typeof setTimeout>;
-type Interval = ReturnType<typeof setInterval>;
-type Nullable<T> = T | null;
-/**
- * WebSocket 自动重连配置。
- */
-interface WSAutoReconnectOptions {
-    /**
-     * 最大重连次数，默认 `3`。
-     */
-    reconnectMaxCount?: number;
-}
-/**
- * WebSocket 心跳配置。
- */
-interface WSHeartbeatOptions {
-    /**
-     * 心跳消息内容，默认 `ping`。
-     */
-    message: string;
-    /**
-     * 心跳间隔，单位毫秒，默认 `3000`。
-     */
-    interval: number;
-}
-/**
- * `WS` 构造函数可选配置。
- */
-interface WSOptions {
-    /**
-     * 是否自动重连。
-     *
-     * - `true`: 使用默认重连策略
-     * - `false`: 不自动重连
-     * - 对象: 自定义重连次数
-     */
-    autoReconnect: boolean | WSAutoReconnectOptions;
-    /**
-     * 是否开启心跳。
-     *
-     * - `false`: 不发送心跳
-     * - `true`: 使用默认心跳策略
-     * - 对象: 自定义心跳内容和间隔
-     */
-    heartbeat: boolean | WSHeartbeatOptions;
-    /**
-     * 需要拼接到 url 上的查询参数。
-     */
-    query: Record<string, string>;
-}
-/**
- * WebSocket 轻量封装，支持自动连接、自动重连、心跳和 query 参数。
- *
- * @example
- * const ws = new WS('wss://example.com/ws', {
- *   autoReconnect: true,
- *   heartbeat: { message: 'ping', interval: 3000 },
- *   query: { token: 'demo-token' },
- * })
- *
- * ws.onMessage((message) => {
- *   console.log(message)
- * })
- *
- * ws.send('hello')
- */
-declare class WS {
-    url: string;
-    socket: WebSocket | null;
-    reconnectCount: number;
-    delay: Nullable<Timeout>;
-    timer: Nullable<Interval>;
-    autoReconnect: WSOptions['autoReconnect'];
-    heartbeat: WSOptions['heartbeat'];
-    query: WSOptions['query'];
-    /**
-     * 创建并立即连接一个 WebSocket 实例。
-     *
-     * @param url WebSocket 地址，例如 `wss://example.com/ws`。
-     * @param options 连接配置，支持重连、心跳和 query 参数。
-     *
-     * @example
-     * const ws = new WS('wss://example.com/ws', {
-     *   autoReconnect: { reconnectMaxCount: 5 },
-     *   heartbeat: { message: 'ping', interval: 5000 },
-     *   query: { token: 'abc123' },
-     * })
-     */
-    constructor(url?: string, options?: WSOptions);
-    /**
-     * 主动发起连接。
-     *
-     * 调用时会先关闭旧连接，再创建新的 WebSocket 实例。
-     *
-     * @example
-     * const ws = new WS('wss://example.com/ws')
-     * ws.connect()
-     */
-    connect(): void;
-    /**
-     * 注册连接成功后的处理逻辑，并在需要时开启心跳。
-     *
-     * @example
-     * const ws = new WS('wss://example.com/ws')
-     * ws.onOpen()
-     */
-    onOpen(): void;
-    /**
-     * 开启心跳发送。
-     *
-     * @example
-     * const ws = new WS('wss://example.com/ws', {
-     *   heartbeat: { message: 'ping', interval: 3000 },
-     * })
-     * ws.startHeartbeat()
-     */
-    startHeartbeat(): void;
-    /**
-     * 注册错误处理和自动重连逻辑。
-     *
-     * @example
-     * const ws = new WS('wss://example.com/ws', { autoReconnect: true })
-     * ws.onError()
-     */
-    onError(): void;
-    /**
-     * 关闭连接并清理相关定时器。
-     *
-     * @example
-     * ws.close()
-     */
-    close(): void;
-    /**
-     * 监听服务端消息。
-     *
-     * 内部会优先尝试将消息解析为 JSON；解析失败时会回传原始 `MessageEvent`。
-     *
-     * @param callback 接收到消息时触发的回调。
-     *
-     * @example
-     * ws.onMessage((message) => {
-     *   console.log(message)
-     * })
-     */
-    onMessage(callback: (data: unknown) => any): void;
-    /**
-     * 发送消息。
-     *
-     * - 如果连接已就绪，会立即发送
-     * - 如果正在连接，会延迟发送
-     * - 如果连接已关闭，会先重新连接再发送
-     *
-     * @param data 需要发送的消息内容。
-     *
-     * @example
-     * ws.send('hello')
-     *
-     * @example
-     * ws.send(JSON.stringify({ type: 'ping' }))
-     */
-    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
-}
-
-export { WS };
-export type { WSAutoReconnectOptions, WSHeartbeatOptions, WSOptions };

package/dist/ws.d.mts

@@ -1,165 +0,0 @@
-type Timeout = ReturnType<typeof setTimeout>;
-type Interval = ReturnType<typeof setInterval>;
-type Nullable<T> = T | null;
-/**
- * WebSocket 自动重连配置。
- */
-interface WSAutoReconnectOptions {
-    /**
-     * 最大重连次数，默认 `3`。
-     */
-    reconnectMaxCount?: number;
-}
-/**
- * WebSocket 心跳配置。
- */
-interface WSHeartbeatOptions {
-    /**
-     * 心跳消息内容，默认 `ping`。
-     */
-    message: string;
-    /**
-     * 心跳间隔，单位毫秒，默认 `3000`。
-     */
-    interval: number;
-}
-/**
- * `WS` 构造函数可选配置。
- */
-interface WSOptions {
-    /**
-     * 是否自动重连。
-     *
-     * - `true`: 使用默认重连策略
-     * - `false`: 不自动重连
-     * - 对象: 自定义重连次数
-     */
-    autoReconnect: boolean | WSAutoReconnectOptions;
-    /**
-     * 是否开启心跳。
-     *
-     * - `false`: 不发送心跳
-     * - `true`: 使用默认心跳策略
-     * - 对象: 自定义心跳内容和间隔
-     */
-    heartbeat: boolean | WSHeartbeatOptions;
-    /**
-     * 需要拼接到 url 上的查询参数。
-     */
-    query: Record<string, string>;
-}
-/**
- * WebSocket 轻量封装，支持自动连接、自动重连、心跳和 query 参数。
- *
- * @example
- * const ws = new WS('wss://example.com/ws', {
- *   autoReconnect: true,
- *   heartbeat: { message: 'ping', interval: 3000 },
- *   query: { token: 'demo-token' },
- * })
- *
- * ws.onMessage((message) => {
- *   console.log(message)
- * })
- *
- * ws.send('hello')
- */
-declare class WS {
-    url: string;
-    socket: WebSocket | null;
-    reconnectCount: number;
-    delay: Nullable<Timeout>;
-    timer: Nullable<Interval>;
-    autoReconnect: WSOptions['autoReconnect'];
-    heartbeat: WSOptions['heartbeat'];
-    query: WSOptions['query'];
-    /**
-     * 创建并立即连接一个 WebSocket 实例。
-     *
-     * @param url WebSocket 地址，例如 `wss://example.com/ws`。
-     * @param options 连接配置，支持重连、心跳和 query 参数。
-     *
-     * @example
-     * const ws = new WS('wss://example.com/ws', {
-     *   autoReconnect: { reconnectMaxCount: 5 },
-     *   heartbeat: { message: 'ping', interval: 5000 },
-     *   query: { token: 'abc123' },
-     * })
-     */
-    constructor(url?: string, options?: WSOptions);
-    /**
-     * 主动发起连接。
-     *
-     * 调用时会先关闭旧连接，再创建新的 WebSocket 实例。
-     *
-     * @example
-     * const ws = new WS('wss://example.com/ws')
-     * ws.connect()
-     */
-    connect(): void;
-    /**
-     * 注册连接成功后的处理逻辑，并在需要时开启心跳。
-     *
-     * @example
-     * const ws = new WS('wss://example.com/ws')
-     * ws.onOpen()
-     */
-    onOpen(): void;
-    /**
-     * 开启心跳发送。
-     *
-     * @example
-     * const ws = new WS('wss://example.com/ws', {
-     *   heartbeat: { message: 'ping', interval: 3000 },
-     * })
-     * ws.startHeartbeat()
-     */
-    startHeartbeat(): void;
-    /**
-     * 注册错误处理和自动重连逻辑。
-     *
-     * @example
-     * const ws = new WS('wss://example.com/ws', { autoReconnect: true })
-     * ws.onError()
-     */
-    onError(): void;
-    /**
-     * 关闭连接并清理相关定时器。
-     *
-     * @example
-     * ws.close()
-     */
-    close(): void;
-    /**
-     * 监听服务端消息。
-     *
-     * 内部会优先尝试将消息解析为 JSON；解析失败时会回传原始 `MessageEvent`。
-     *
-     * @param callback 接收到消息时触发的回调。
-     *
-     * @example
-     * ws.onMessage((message) => {
-     *   console.log(message)
-     * })
-     */
-    onMessage(callback: (data: unknown) => any): void;
-    /**
-     * 发送消息。
-     *
-     * - 如果连接已就绪，会立即发送
-     * - 如果正在连接，会延迟发送
-     * - 如果连接已关闭，会先重新连接再发送
-     *
-     * @param data 需要发送的消息内容。
-     *
-     * @example
-     * ws.send('hello')
-     *
-     * @example
-     * ws.send(JSON.stringify({ type: 'ping' }))
-     */
-    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
-}
-
-export { WS };
-export type { WSAutoReconnectOptions, WSHeartbeatOptions, WSOptions };