@lobehub/chat 1.98.2 → 1.99.0

package/src/utils/number.ts

@@ -0,0 +1,25 @@
+import prand from 'pure-rand';
+
+export const MAX_SEED = 2 ** 31 - 1;
+export function generateUniqueSeeds(seedCount: number): number[] {
+  // Use current timestamp as the initial seed
+  const initialSeed = Date.now();
+
+  // Create an instance of Xoroshiro128+ random number generator
+  let rng = prand.xoroshiro128plus(initialSeed);
+
+  const seeds = new Set<number>();
+
+  while (seeds.size < seedCount) {
+    // Generate a 31-bit random integer (PostgreSQL INTEGER compatible)
+    const [randomInt, nextRng] = prand.uniformIntDistribution(0, MAX_SEED, rng);
+
+    // Update RNG state
+    rng = nextRng;
+
+    // Add to the set, ensuring uniqueness
+    seeds.add(randomInt);
+  }
+
+  return Array.from(seeds);
+}

package/src/utils/server/__tests__/geo.test.ts

@@ -63,11 +63,13 @@ describe('parseDefaultThemeFromCountry', () => {
       timezones: ['America/New_York'],
     });
 
-    const mockDate = new Date('2025-04-01T12:00:00');
+    // 设置UTC时间16:00，这样在纽约时区（EDT，UTC-4）就是12:00
+    const mockDate = new Date('2025-04-01T16:00:00.000Z');
     vi.setSystemTime(mockDate);
 
     const request = mockRequest();
-    expect(parseDefaultThemeFromCountry(request)).toBe('light');
+    const result = parseDefaultThemeFromCountry(request);
+    expect(result).toBe('light');
   });
 
   it('should return dark theme during night hours', () => {
@@ -78,7 +80,8 @@ describe('parseDefaultThemeFromCountry', () => {
       timezones: ['America/New_York'],
     });
 
-    const mockDate = new Date('2025-04-01T22:00:00');
+    // 设置UTC时间02:00，这样在纽约时区（EDT，UTC-4）就是22:00
+    const mockDate = new Date('2025-04-01T02:00:00.000Z');
     vi.setSystemTime(mockDate);
 
     const request = mockRequest();

package/src/utils/storeDebug.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it } from 'vitest';
+
+import { setNamespace } from './storeDebug';
+
+describe('storeDebug utilities', () => {
+  describe('setNamespace', () => {
+    it('should create a namespaced action creator', () => {
+      const createAction = setNamespace('user');
+
+      expect(typeof createAction).toBe('function');
+    });
+
+    it('should return string action type when no payload provided', () => {
+      const createAction = setNamespace('user');
+      const actionType = createAction('login');
+
+      expect(actionType).toBe('user/login');
+      expect(typeof actionType).toBe('string');
+    });
+
+    it('should return action object when payload provided', () => {
+      const createAction = setNamespace('user');
+      const action = createAction('login', { email: 'test@example.com' });
+
+      expect(action).toEqual({
+        type: 'user/login',
+        payload: { email: 'test@example.com' },
+      });
+      expect(typeof action).toBe('object');
+    });
+
+    it('should handle empty namespace', () => {
+      const createAction = setNamespace('');
+      const actionType = createAction('action');
+
+      expect(actionType).toBe('action');
+    });
+
+    it('should handle truthy payload values (return objects)', () => {
+      const createAction = setNamespace('data');
+
+      // String payload
+      const stringAction = createAction('update', 'hello');
+      expect(stringAction).toEqual({
+        type: 'data/update',
+        payload: 'hello',
+      });
+
+      // Number payload
+      const numberAction = createAction('increment', 42);
+      expect(numberAction).toEqual({
+        type: 'data/increment',
+        payload: 42,
+      });
+
+      // Boolean payload
+      const booleanAction = createAction('toggle', true);
+      expect(booleanAction).toEqual({
+        type: 'data/toggle',
+        payload: true,
+      });
+
+      // Array payload
+      const arrayAction = createAction('batch', [1, 2, 3]);
+      expect(arrayAction).toEqual({
+        type: 'data/batch',
+        payload: [1, 2, 3],
+      });
+    });
+
+    it('should handle falsy payload values (return strings)', () => {
+      const createAction = setNamespace('data');
+
+      // Null payload (falsy)
+      const nullAction = createAction('reset', null);
+      expect(nullAction).toBe('data/reset');
+
+      // Undefined payload (falsy)
+      const undefinedAction = createAction('clear', undefined);
+      expect(undefinedAction).toBe('data/clear');
+
+      // Zero payload (falsy)
+      const zeroAction = createAction('setValue', 0);
+      expect(zeroAction).toBe('data/setValue');
+
+      // Empty string payload (falsy)
+      const emptyStringAction = createAction('clearField', '');
+      expect(emptyStringAction).toBe('data/clearField');
+
+      // False payload (falsy)
+      const falseAction = createAction('disable', false);
+      expect(falseAction).toBe('data/disable');
+    });
+
+    it('should handle complex nested object payload', () => {
+      const createAction = setNamespace('app');
+      const complexPayload = {
+        user: {
+          id: 123,
+          profile: {
+            name: 'John Doe',
+            settings: {
+              theme: 'dark',
+              notifications: true,
+            },
+          },
+        },
+        metadata: {
+          timestamp: Date.now(),
+          source: 'api',
+        },
+      };
+
+      const action = createAction('userUpdate', complexPayload);
+
+      expect(action).toEqual({
+        type: 'app/userUpdate',
+        payload: complexPayload,
+      });
+    });
+
+    it('should create unique namespaces for different instances', () => {
+      const userActions = setNamespace('user');
+      const postActions = setNamespace('post');
+
+      const userLogin = userActions('login');
+      const postCreate = postActions('create');
+
+      expect(userLogin).toBe('user/login');
+      expect(postCreate).toBe('post/create');
+    });
+
+    it('should handle special characters in namespace and type', () => {
+      const createAction = setNamespace('my-feature_v2');
+      const actionType = createAction('save-data_with-id');
+
+      expect(actionType).toBe('my-feature_v2/save-data_with-id');
+    });
+
+    it('should maintain type consistency across calls', () => {
+      const createAction = setNamespace('counter');
+
+      // Multiple calls should work consistently
+      const increment1 = createAction('increment');
+      const increment2 = createAction('increment');
+
+      expect(increment1).toBe('counter/increment');
+      expect(increment2).toBe('counter/increment');
+      expect(increment1).toBe(increment2);
+    });
+  });
+});

package/src/utils/storeDebug.ts

@@ -1,11 +1,20 @@
 export const setNamespace = (namespace: string) => {
-  return (type: string, payload?: any) => {
+  return <P = undefined>(type: string, payload?: P) => {
     const name = [namespace, type].filter(Boolean).join('/');
-    return payload
-      ? {
-          payload,
-          type: name,
-        }
-      : name;
+    return (
+      payload
+        ? {
+            payload,
+            type: name,
+          }
+        : name
+    ) as P extends undefined ? string : { payload: P; type: string };
   };
 };
+
+export type Action =
+  | string
+  | {
+      [x: string | number | symbol]: unknown;
+      type: string;
+    };

package/src/utils/time.test.ts

@@ -0,0 +1,259 @@
+import dayjs from 'dayjs';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  daysAgo,
+  getYYYYmmddHHMMss,
+  hoursAgo,
+  lastMonth,
+  monthsAgo,
+  thisMonth,
+  thisQuarter,
+  thisWeek,
+  thisYear,
+  today,
+  weeksAgo,
+} from './time';
+
+describe('time utilities', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    // Set a fixed date for consistent testing: 2024-06-15 14:30:45 (local time)
+    vi.setSystemTime(new Date('2024-06-15T14:30:45.123'));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  describe('today', () => {
+    it('should return the start of the current day', () => {
+      const result = today();
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-06-15 00:00:00');
+    });
+  });
+
+  describe('thisWeek', () => {
+    it('should return the start of the current week', () => {
+      const result = thisWeek();
+
+      // dayjs starts week on Sunday by default
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-06-09 00:00:00');
+    });
+  });
+
+  describe('thisMonth', () => {
+    it('should return the start of the current month', () => {
+      const result = thisMonth();
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-06-01 00:00:00');
+    });
+  });
+
+  describe('thisQuarter', () => {
+    it('should return the start of the current quarter (Q2)', () => {
+      const result = thisQuarter();
+
+      // June is in Q2, which starts in April (month 3, 0-indexed)
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-04-01 00:00:00');
+    });
+
+    it('should work correctly for Q1 (January)', () => {
+      vi.setSystemTime(new Date('2024-01-15T14:30:45.123'));
+      const result = thisQuarter();
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-01-01 00:00:00');
+    });
+
+    it('should work correctly for Q3 (September)', () => {
+      vi.setSystemTime(new Date('2024-09-15T14:30:45.123'));
+      const result = thisQuarter();
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-07-01 00:00:00');
+    });
+
+    it('should work correctly for Q4 (December)', () => {
+      vi.setSystemTime(new Date('2024-12-15T14:30:45.123'));
+      const result = thisQuarter();
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-10-01 00:00:00');
+    });
+  });
+
+  describe('thisYear', () => {
+    it('should return the start of the current year', () => {
+      const result = thisYear();
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-01-01 00:00:00');
+    });
+  });
+
+  describe('hoursAgo', () => {
+    it('should return the correct time hours ago', () => {
+      const result = hoursAgo(3);
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-06-15 11:00:00');
+    });
+
+    it('should handle 0 hours ago', () => {
+      const result = hoursAgo(0);
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-06-15 14:00:00');
+    });
+
+    it('should handle large hour values (cross day boundary)', () => {
+      const result = hoursAgo(25);
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-06-14 13:00:00');
+    });
+  });
+
+  describe('daysAgo', () => {
+    it('should return the correct date days ago', () => {
+      const result = daysAgo(7);
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-06-08 00:00:00');
+    });
+
+    it('should handle 0 days ago (today)', () => {
+      const result = daysAgo(0);
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-06-15 00:00:00');
+    });
+
+    it('should handle large day values (cross month boundary)', () => {
+      const result = daysAgo(30);
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-05-16 00:00:00');
+    });
+  });
+
+  describe('weeksAgo', () => {
+    it('should return the correct week weeks ago', () => {
+      const result = weeksAgo(2);
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-05-26 00:00:00');
+    });
+
+    it('should handle 0 weeks ago (this week)', () => {
+      const result = weeksAgo(0);
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-06-09 00:00:00');
+    });
+  });
+
+  describe('monthsAgo', () => {
+    it('should return the correct month months ago', () => {
+      const result = monthsAgo(3);
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-03-01 00:00:00');
+    });
+
+    it('should handle 0 months ago (this month)', () => {
+      const result = monthsAgo(0);
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-06-01 00:00:00');
+    });
+
+    it('should handle cross year boundary', () => {
+      const result = monthsAgo(12);
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2023-06-01 00:00:00');
+    });
+  });
+
+  describe('lastMonth', () => {
+    it('should return the end of last month', () => {
+      const result = lastMonth();
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-05-31 23:59:59');
+    });
+
+    it('should work correctly for January (December of previous year)', () => {
+      vi.setSystemTime(new Date('2024-01-15T14:30:45.123'));
+      const result = lastMonth();
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2023-12-31 23:59:59');
+    });
+
+    it('should work correctly for March (February with 29 days in leap year)', () => {
+      vi.setSystemTime(new Date('2024-03-15T14:30:45.123'));
+      const result = lastMonth();
+
+      expect(result.format('YYYY-MM-DD HH:mm:ss')).toBe('2024-02-29 23:59:59');
+    });
+  });
+
+  describe('getYYYYmmddHHMMss', () => {
+    it('should format date to YYYYMMDD_HHmmss format', () => {
+      const date = new Date('2024-01-01T23:59:59.123');
+      const result = getYYYYmmddHHMMss(date);
+
+      expect(result).toBe('20240101_235959');
+    });
+
+    it('should format date with zero padding', () => {
+      const date = new Date('2024-02-05T01:02:03.456');
+      const result = getYYYYmmddHHMMss(date);
+
+      expect(result).toBe('20240205_010203');
+    });
+
+    it('should handle end of year date', () => {
+      const date = new Date('2024-12-31T00:00:00.000');
+      const result = getYYYYmmddHHMMss(date);
+
+      expect(result).toBe('20241231_000000');
+    });
+
+    it('should handle leap year date', () => {
+      const date = new Date('2024-02-29T12:30:45.789');
+      const result = getYYYYmmddHHMMss(date);
+
+      expect(result).toBe('20240229_123045');
+    });
+
+    it('should work with the current mocked time', () => {
+      const date = new Date('2024-06-15T14:30:45.123');
+      const result = getYYYYmmddHHMMss(date);
+
+      expect(result).toBe('20240615_143045');
+    });
+  });
+
+  describe('edge cases and integration', () => {
+    it('should all return dayjs objects for date functions', () => {
+      expect(dayjs.isDayjs(today())).toBe(true);
+      expect(dayjs.isDayjs(thisWeek())).toBe(true);
+      expect(dayjs.isDayjs(thisMonth())).toBe(true);
+      expect(dayjs.isDayjs(thisQuarter())).toBe(true);
+      expect(dayjs.isDayjs(thisYear())).toBe(true);
+      expect(dayjs.isDayjs(hoursAgo(1))).toBe(true);
+      expect(dayjs.isDayjs(daysAgo(1))).toBe(true);
+      expect(dayjs.isDayjs(weeksAgo(1))).toBe(true);
+      expect(dayjs.isDayjs(monthsAgo(1))).toBe(true);
+      expect(dayjs.isDayjs(lastMonth())).toBe(true);
+    });
+
+    it('should maintain consistency between different time functions', () => {
+      const todayResult = today();
+      const daysAgoResult = daysAgo(0);
+
+      expect(todayResult.format('YYYY-MM-DD')).toBe(daysAgoResult.format('YYYY-MM-DD'));
+    });
+
+    it('should work with different time zones in getYYYYmmddHHMMss', () => {
+      // Note: dayjs uses the local timezone by default
+      const localDate = new Date('2024-06-15T14:30:45.000');
+      const result = getYYYYmmddHHMMss(localDate);
+
+      // The exact result depends on the test environment's timezone
+      // But it should always be a valid format
+      expect(result).toMatch(/^\d{8}_\d{6}$/);
+      expect(result).toHaveLength(15);
+      // Should match the local time format
+      expect(result).toBe('20240615_143045');
+    });
+  });
+});

package/src/utils/time.ts

@@ -21,3 +21,21 @@ export const weeksAgo = (weeks: number) => dayjs().subtract(weeks, 'week').start
 export const monthsAgo = (months: number) => dayjs().subtract(months, 'month').startOf('month');
 
 export const lastMonth = () => monthsAgo(1).endOf('month');
+
+/**
+ * Get the date in the format of YYYYMMdd_HHmmss like 20240101_235959
+ *
+ * @example
+ *
+ * ```ts
+ * getYYYYmmddHHMMss(new Date('2024-01-01 23:59:59')); // returns '20240101_235959'
+ * getYYYYmmddHHMMss(new Date('2024-12-31 00:00:00')); // returns '20241231_000000'
+ * ```
+ *
+ * @param date - The date to format
+ * @returns A string in YYYYMMdd_HHmmss format with underscore separator between date and time
+ * @see https://day.js.org/docs/en/display/format
+ */
+export function getYYYYmmddHHMMss(date: Date) {
+  return dayjs(date).format('YYYYMMDD_HHmmss');
+}

package/src/utils/units.ts

@@ -0,0 +1,61 @@
+// ------------------------ Time -----------------------------
+
+export const MS = 1;
+
+/**
+ * `1000ms`
+ */
+export const SECOND = 1000 * MS;
+
+/**
+ * `60s`
+ */
+export const MINUTE = 60 * SECOND;
+
+/**
+ * `3600s`
+ */
+export const HOUR = 60 * MINUTE;
+
+/**
+ * `86400s`
+ */
+export const DAY = 24 * HOUR;
+
+/**
+ * `2592000s`
+ */
+export const MONTH = 30 * DAY;
+
+/**
+ * `31536000s`
+ */
+export const YEAR = 365 * DAY;
+
+export const API_TEST_TIMEOUT = 10 * SECOND;
+
+// ------------------------ Size -----------------------------
+
+/**
+ * `1024 bytes`
+ */
+export const KiB = 1024;
+
+/**
+ * `1024 KiB` (1,048,576 bytes)
+ */
+export const MiB = 1024 * KiB;
+
+/**
+ * `1024 MiB` (1,073,741,824 bytes)
+ */
+export const GiB = 1024 * MiB;
+
+/**
+ * `1024 GiB` (1,099,511,627,776 bytes)
+ */
+export const TiB = 1024 * GiB;
+
+export const DOLLAR_PER_CREDIT = 0.003;
+export const DOLLAR_PER_RMB = 0.14;
+export const RMB_PER_CREDIT = DOLLAR_PER_RMB / DOLLAR_PER_CREDIT;