@wener/common 2.0.2 → 2.0.3

package/src/cn/pinyin/loader.ts

@@ -0,0 +1,12 @@
+import { setCharToPinyinTable } from './toPinyinPure';
+import { transformData } from './transform';
+
+export function loadCharToPinyinTable(): Promise<Record<string, string[]>> {
+	return import('./data.json' as unknown as string, { with: { type: 'json' } })
+		.then((v) => v.default as Record<string, string[]>)
+		.then((data) => {
+			let out = transformData(data);
+			setCharToPinyinTable(out);
+			return out;
+		});
+}

package/src/cn/pinyin/preload.ts

@@ -0,0 +1,3 @@
+import { loadCharToPinyinTable } from './loader';
+
+await loadCharToPinyinTable();

package/src/cn/pinyin/toPinyin.test.ts

@@ -0,0 +1,12 @@
+import { assert, test } from 'vitest';
+import { loadCharToPinyinTable } from './loader';
+import { toPinyinPure } from './toPinyinPure';
+
+test('toPinyin', async () => {
+	await loadCharToPinyinTable();
+	assert.deepEqual(toPinyinPure('真思'), ['zhen,sai', 'zhen,si']);
+
+	// char to py -> 350k
+	// py to char -> 145k
+	// csv -> 96k
+});

package/src/cn/pinyin/toPinyinPure.ts

@@ -0,0 +1,43 @@
+import { cartesianProduct } from './cartesianProduct';
+
+let CharToPinyinTable: Record<string, string[]> | undefined;
+
+export function setCharToPinyinTable(table: Record<string, string[]>) {
+	CharToPinyinTable = table;
+}
+
+export function getCharToPinyinTable() {
+	if (!CharToPinyinTable) {
+		return {};
+	}
+	return CharToPinyinTable;
+}
+
+export function toPinyinPureFirst(s: string, sep = ','): string {
+	let tab = getCharToPinyinTable();
+	return s
+		.split('')
+		.map((c) => tab[c]?.[0])
+		.filter(Boolean)
+		.join(sep);
+}
+
+export function toPinyinPure(s: string, sep = ','): string[] {
+	let tab = getCharToPinyinTable();
+	// ensure order
+	return cartesianProduct(s.split('').map((c) => tab[c] || ''))
+		.sort((a, b) => {
+			for (let i = 0; i < a.length; i++) {
+				let x = a[i];
+				let y = b[i];
+				if (x < y) return -1;
+				if (x > y) return 1;
+			}
+			return 0;
+		})
+		.map((v) => v.filter(Boolean).join(sep));
+}
+
+// export function lookupPinyinPure(s: string): Array<Array<string>> {
+//   return cartesianProductOfArray(s.split('').map(c => Lookup[c]));
+// }

package/src/cn/pinyin/transform.ts

@@ -0,0 +1,12 @@
+export function transformData(input: Record<string, string[]>) {
+	let out = {} as Record<string, string[]>;
+	for (let [py, chars] of Object.entries(input)) {
+		for (let c of chars) {
+			if (!out[c]) {
+				out[c] = [];
+			}
+			out[c].push(py);
+		}
+	}
+	return out;
+}

package/src/consola/formatLogObject.test.ts

@@ -0,0 +1,27 @@
+import consola from 'consola';
+import { Consola, type ConsolaInstance } from 'consola/core';
+import { test } from 'vitest';
+import { createStandardConsolaReporter } from './createStandardConsolaReporter';
+
+test('formatLogObject', async () => {
+	const log: ConsolaInstance = new Consola({
+		reporters: [createStandardConsolaReporter({})],
+	}).create({
+		formatOptions: {
+			colors: true,
+		},
+	});
+	consola.warn({ name: 'wener' });
+
+	log.info({ name: 'wener' });
+	log.info('message', {
+		name: 'wener',
+	});
+	log.info('complex object', {
+		name: 'wener',
+		age: 30,
+		active: true,
+		tags: ['developer', 'typescript'],
+		meta: { level: 'senior', remote: true },
+	});
+});

package/src/consola/formatLogObject.ts

@@ -80,7 +80,7 @@ export function formatLogObject(
 	}
 
 	{
-		const [message, ...additional] = formatArgs(o.args, ctx).split('\n');
+		const [message, ...additional] = formatArgs(o.args, { colors: shouldColor }).split('\n');
 
 		out.push(characterFormat(message));
 
@@ -159,16 +159,44 @@ function formatArgs(args: any[], opts: FormatOptions) {
 
 	// Only supported with Node >= 10
 	// https://nodejs.org/api/util.html#util_util_inspect_object_options
-	return formatWithOptions(opts, ..._args);
+	return formatWithOptions(Boolean(opts.colors), ..._args);
 }
 
-function formatWithOptions(o: any, ...params: any[]) {
-	// import { formatWithOptions } from 'node:util';
-	return params.join(' ');
+function formatWithOptions(shouldColor: boolean, ...params: any[]) {
+	return params.map((value) => formatValue(value, shouldColor)).join(' ');
+}
+
+function formatValue(value: any, shouldColor: boolean = false): string {
+	const colors = shouldColor ? Colors : NoColors;
+
+	if (value === null) return 'null';
+	if (value === undefined) return 'undefined';
+	if (typeof value === 'string') return value;
+	if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+
+	if (typeof value === 'object' && value.constructor === Object) {
+		const entries = Object.entries(value);
+		if (entries.length === 0) return '{}';
+		return entries
+			.map(([key, val]) => {
+				const keyStr = shouldColor ? colors.blue(key) : key;
+				const valStr = shouldColor ? colors.green(JSON.stringify(val)) : JSON.stringify(val);
+				return `${keyStr}=${valStr}`;
+			})
+			.join(' ');
+	}
+
+	// For arrays and other objects, use JSON.stringify directly
+	try {
+		const result = JSON.stringify(value);
+		return shouldColor ? colors.green(result) : result;
+	} catch {
+		return String(value);
+	}
 }
 
 function formatError(err: any, opts: FormatOptions): string {
-	const message = err.message ?? formatWithOptions(opts, err);
+	const message = err.message ?? formatWithOptions(Boolean(opts.colors), err);
 	const stack = err.stack ? formatStack(err.stack, message, opts) : '';
 
 	const level = opts?.errorLevel || 0;

package/src/dayjs/dayjs.ts

@@ -1,22 +1,22 @@
 import dayjs from 'dayjs';
-import advancedFormat from 'dayjs/plugin/advancedFormat';
-import dayOfYear from 'dayjs/plugin/dayOfYear';
-import duration from 'dayjs/plugin/duration';
-import isBetween from 'dayjs/plugin/isBetween';
-import isSameOrAfter from 'dayjs/plugin/isSameOrAfter';
-import isSameOrBefore from 'dayjs/plugin/isSameOrBefore';
-import isToday from 'dayjs/plugin/isToday';
-import isTomorrow from 'dayjs/plugin/isTomorrow';
-import isYesterday from 'dayjs/plugin/isYesterday';
-import localeData from 'dayjs/plugin/localeData';
-import objectSupport from 'dayjs/plugin/objectSupport';
-import quarterOfYear from 'dayjs/plugin/quarterOfYear';
-import relativeTime from 'dayjs/plugin/relativeTime';
-import timezone from 'dayjs/plugin/timezone';
-import toObject from 'dayjs/plugin/toObject';
-import utc from 'dayjs/plugin/utc';
-import 'dayjs/locale/zh-cn';
-import 'dayjs/locale/zh';
+import advancedFormat from 'dayjs/plugin/advancedFormat.js';
+import dayOfYear from 'dayjs/plugin/dayOfYear.js';
+import duration from 'dayjs/plugin/duration.js';
+import isBetween from 'dayjs/plugin/isBetween.js';
+import isSameOrAfter from 'dayjs/plugin/isSameOrAfter.js';
+import isSameOrBefore from 'dayjs/plugin/isSameOrBefore.js';
+import isToday from 'dayjs/plugin/isToday.js';
+import isTomorrow from 'dayjs/plugin/isTomorrow.js';
+import isYesterday from 'dayjs/plugin/isYesterday.js';
+import localeData from 'dayjs/plugin/localeData.js';
+import objectSupport from 'dayjs/plugin/objectSupport.js';
+import quarterOfYear from 'dayjs/plugin/quarterOfYear.js';
+import relativeTime from 'dayjs/plugin/relativeTime.js';
+import timezone from 'dayjs/plugin/timezone.js';
+import toObject from 'dayjs/plugin/toObject.js';
+import utc from 'dayjs/plugin/utc.js';
+import 'dayjs/locale/zh-cn.js';
+import 'dayjs/locale/zh.js';
 
 dayjs.extend(advancedFormat);
 dayjs.extend(dayOfYear);

package/src/dayjs/index.ts

@@ -1,3 +1,5 @@
 export { dayjs } from './dayjs';
-export { parseDuration } from './parseDuration';
+export { parseDuration, type MaybeDuration } from './parseDuration';
 export { formatDuration } from './formatDuration';
+
+export { resolveRelativeTime } from './resolveRelativeTime';

package/src/dayjs/parseRelativeTime.test.ts

@@ -0,0 +1,185 @@
+import dayjs from 'dayjs';
+import duration from 'dayjs/plugin/duration';
+import { describe, expect, it } from 'vitest';
+import { parseRelativeTime } from './parseRelativeTime';
+
+dayjs.extend(duration);
+
+describe('parseRelativeTime', () => {
+	it('should return empty array for "now"', () => {
+		const result = parseRelativeTime('now');
+		expect(result).toEqual([]);
+	});
+
+	it('should parse simple addition operations', () => {
+		const result = parseRelativeTime('now+1h');
+		expect(result).toHaveLength(1);
+		expect(result[0]).toEqual({
+			operator: '+',
+			duration: dayjs.duration({ hours: 1 }),
+		});
+	});
+
+	it('should parse simple subtraction operations', () => {
+		const result = parseRelativeTime('now-30m');
+		expect(result).toHaveLength(1);
+		expect(result[0]).toEqual({
+			operator: '-',
+			duration: dayjs.duration({ minutes: 30 }),
+		});
+	});
+
+	it('should parse milliseconds', () => {
+		const result = parseRelativeTime('now+500ms');
+		expect(result).toHaveLength(1);
+		expect(result[0]).toEqual({
+			operator: '+',
+			duration: dayjs.duration({ milliseconds: 500 }),
+		});
+	});
+
+	it('should parse complex duration combinations', () => {
+		const result = parseRelativeTime('now+1d6h30m');
+		expect(result).toHaveLength(1);
+		expect(result[0]).toEqual({
+			operator: '+',
+			duration: dayjs.duration({ days: 1, hours: 6, minutes: 30 }),
+		});
+	});
+
+	it('should parse truncation operations', () => {
+		const result = parseRelativeTime('now/d');
+		expect(result).toHaveLength(1);
+		expect(result[0]).toEqual({
+			operator: '/',
+			unit: 'd',
+		});
+
+		const result2 = parseRelativeTime('now\\M');
+		expect(result2).toHaveLength(1);
+		expect(result2[0]).toEqual({
+			operator: '\\',
+			unit: 'M',
+		});
+	});
+
+	it('should parse multiple operations', () => {
+		const result = parseRelativeTime('now-1h+30m');
+		expect(result).toHaveLength(2);
+		expect(result[0]).toEqual({
+			operator: '-',
+			duration: dayjs.duration({ hours: 1 }),
+		});
+		expect(result[1]).toEqual({
+			operator: '+',
+			duration: dayjs.duration({ minutes: 30 }),
+		});
+	});
+
+	it('should parse mixed arithmetic and truncation operations', () => {
+		const result = parseRelativeTime('now-1M/M');
+		expect(result).toHaveLength(2);
+		expect(result[0]).toEqual({
+			operator: '-',
+			duration: dayjs.duration({ months: 1 }),
+		});
+		expect(result[1]).toEqual({
+			operator: '/',
+			unit: 'M',
+		});
+	});
+
+	it('should handle all supported units', () => {
+		const units = ['ms', 's', 'm', 'h', 'd', 'w', 'M', 'Q', 'y'];
+
+		for (const unit of units) {
+			const result = parseRelativeTime(`now+1${unit}`);
+			expect(result).toHaveLength(1);
+			expect(result[0]).toEqual({
+				operator: '+',
+				duration: dayjs.duration({ [unit]: 1 }),
+			});
+		}
+	});
+
+	it('should handle complex multi-unit expressions', () => {
+		const result = parseRelativeTime('now+1y2M3w4d5h6m7s8ms');
+		expect(result).toHaveLength(1);
+		expect(result[0]).toEqual({
+			operator: '+',
+			duration: dayjs.duration({
+				years: 1,
+				months: 2,
+				weeks: 3,
+				days: 4,
+				hours: 5,
+				minutes: 6,
+				seconds: 7,
+				milliseconds: 8,
+			}),
+		});
+	});
+
+	it('should handle same unit multiple times (should sum)', () => {
+		const result = parseRelativeTime('now+1h2h3h');
+		expect(result).toHaveLength(1);
+		expect(result[0]).toEqual({
+			operator: '+',
+			duration: dayjs.duration({ hours: 6 }), // 1+2+3
+		});
+	});
+
+	it('should throw error for invalid format', () => {
+		expect(() => parseRelativeTime('invalid')).toThrow('Invalid relative time format');
+		expect(() => parseRelativeTime('now+')).toThrow('Invalid relative time format');
+		expect(() => parseRelativeTime('now+abc')).toThrow('Invalid duration specification');
+	});
+
+	it('should throw error for invalid units in truncation', () => {
+		expect(() => parseRelativeTime('now/invalid')).toThrow('Invalid unit');
+	});
+
+	it('should throw error for invalid units in duration', () => {
+		expect(() => parseRelativeTime('now+1invalid')).toThrow('Invalid unit');
+	});
+
+	it('should handle whitespace correctly', () => {
+		// The regex should handle operands without extra whitespace issues
+		const result = parseRelativeTime('now+1h30m');
+		expect(result).toHaveLength(1);
+		expect(result[0]).toEqual({
+			operator: '+',
+			duration: dayjs.duration({ hours: 1, minutes: 30 }),
+		});
+	});
+
+	it('should parse real-world examples', () => {
+		// Last 24 hours
+		const result1 = parseRelativeTime('now-24h');
+		expect(result1).toHaveLength(1);
+		expect(result1[0]).toEqual({
+			operator: '-',
+			duration: dayjs.duration({ hours: 24 }),
+		});
+
+		// Start of previous month
+		const result2 = parseRelativeTime('now-1M/M');
+		expect(result2).toHaveLength(2);
+		expect(result2[0]).toEqual({
+			operator: '-',
+			duration: dayjs.duration({ months: 1 }),
+		});
+		expect(result2[1]).toEqual({
+			operator: '/',
+			unit: 'M',
+		});
+
+		// Complex time ago
+		const result3 = parseRelativeTime('now-1w2d3h');
+		expect(result3).toHaveLength(1);
+		expect(result3[0]).toEqual({
+			operator: '-',
+			duration: dayjs.duration({ weeks: 1, days: 2, hours: 3 }),
+		});
+	});
+});

package/src/dayjs/parseRelativeTime.ts

@@ -0,0 +1,115 @@
+import dayjs from 'dayjs';
+import type { Duration } from 'dayjs/plugin/duration';
+import { checkDurationUnit, RelativeDurationUnits, type RelativeDurationUnit } from './resolveRelativeTime';
+
+export type TimeOperation =
+	| {
+			operator: '+' | '-';
+			duration: Duration;
+	  }
+	| {
+			operator: '/' | '\\';
+			unit: RelativeDurationUnit;
+	  };
+
+/**
+ * Parses a relative time string and returns an array of operations.
+ *
+ * @param s - The relative time string to parse (must start with "now")
+ * @returns Array of operations that can be applied sequentially
+ * @throws {Error} When the format is invalid
+ *
+ * @example
+ * ```typescript
+ * parseRelativeTime('now-1h+30m')    // [{ operator: '-', duration: dayjs.duration(1, 'h') }, { operator: '+', duration: dayjs.duration(30, 'm') }]
+ * parseRelativeTime('now+1d6h')      // [{ operator: '+', duration: dayjs.duration({ days: 1, hours: 6 }) }]
+ * parseRelativeTime('now/d')         // [{ operator: '/', unit: 'd' }]
+ * parseRelativeTime('now\\M')        // [{ operator: '\\', unit: 'M' }]
+ * parseRelativeTime('now-1M/M')      // [{ operator: '-', duration: dayjs.duration(1, 'M') }, { operator: '/', unit: 'M' }]
+ * parseRelativeTime('now+500ms')     // [{ operator: '+', duration: dayjs.duration(500, 'ms') }]
+ * ```
+ */
+export function parseRelativeTime(s: string): TimeOperation[] {
+	if (typeof s !== 'string' || !s.startsWith('now')) {
+		throw new Error(`Invalid relative time format: ${s}`);
+	}
+
+	const remaining = s.slice(3); // Remove 'now'
+
+	if (!remaining) {
+		return [];
+	}
+
+	const operations: TimeOperation[] = [];
+
+	// Single regex to match all operations: <op><duration_spec> or <op><unit>
+	// Where duration_spec can be: 1h, 1d6h, 500ms, etc.
+	const operationRegex = /([+\-/\\])([^+\-/\\]+)/g;
+	let match: RegExpExecArray | null;
+	let lastIndex = 0;
+
+	while ((match = operationRegex.exec(remaining)) !== null) {
+		const [, operator, operand] = match;
+
+		if (operator === '/' || operator === '\\') {
+			// Truncation operation - single unit only
+			checkDurationUnit(operand.trim());
+			operations.push({
+				operator: operator as '/' | '\\',
+				unit: operand.trim() as RelativeDurationUnit,
+			});
+		} else {
+			// Addition or subtraction operation - parse complex duration
+			const parsedDuration = parseDurationSpec(operand.trim());
+			operations.push({
+				operator: operator as '+' | '-',
+				duration: parsedDuration,
+			});
+		}
+		lastIndex = operationRegex.lastIndex;
+	}
+
+	// Check if we parsed the entire remaining string
+	if (lastIndex < remaining.length) {
+		throw new Error(`Invalid relative time format: ${s}`);
+	}
+
+	return operations;
+}
+
+/**
+ * Parses a duration specification like "1h", "1d6h", "500ms" into a dayjs Duration.
+ * Supports multiple units in a single specification.
+ */
+function parseDurationSpec(spec: string): Duration {
+	// Match all number+unit pairs: 1d, 6h, 30m, 500ms, etc.
+	const durationRegex = /(\d+)(ms|[smhdwMQy])/g;
+	const durationObj: Record<string, number> = {};
+	let match: RegExpExecArray | null;
+	let hasMatch = false;
+
+	while ((match = durationRegex.exec(spec)) !== null) {
+		const [, amountStr, unit] = match;
+		checkDurationUnit(unit);
+		const amount = parseInt(amountStr, 10);
+
+		// Dayjs duration supports unit strings directly
+		durationObj[unit] = (durationObj[unit] || 0) + amount;
+		hasMatch = true;
+	}
+
+	if (!hasMatch) {
+		// Check if there are invalid units by looking for number+invalid_unit patterns
+		const invalidUnitRegex = /\d+([a-zA-Z]+)/g;
+		let invalidMatch: RegExpExecArray | null;
+		while ((invalidMatch = invalidUnitRegex.exec(spec)) !== null) {
+			const [, unit] = invalidMatch;
+			if (!RelativeDurationUnits.includes(unit as RelativeDurationUnit)) {
+				throw new Error(`Invalid unit: ${unit}`);
+			}
+		}
+		throw new Error(`Invalid duration specification: ${spec}`);
+	}
+
+	return dayjs.duration(durationObj);
+}