@wener/common 2.0.1 → 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

@@ -1,9 +1,9 @@
-import colors from 'chalk';
+import colors, { Chalk, type ChalkInstance } from 'chalk';
 import type { ConsolaOptions, FormatOptions, LogObject, LogType } from 'consola/core';
 import dayjs from 'dayjs';
 import { isDevelopment } from 'std-env';
 
-const levelColors: Record<LogType, (str: string) => string> = {
+const LevelColors: Record<LogType, (str: string) => string> = {
 	trace: colors.gray,
 	debug: colors.cyan,
 	info: colors.blueBright,
@@ -38,16 +38,24 @@ const levelShort: Record<LogType, string> = {
 };
 const start = Date.now();
 
+const Colors: ChalkInstance = colors;
+const NoColors = new Chalk({ level: 0 });
+
 export function formatLogObject(
 	o: LogObject,
 	ctx: {
 		options: ConsolaOptions;
 	},
 ) {
+	const shouldColor = Boolean(ctx.options?.formatOptions?.colors);
+
 	let { date, type, tag } = o;
 	type = type === 'log' ? 'info' : type;
-
-	const color = levelColors[type] || colors.white;
+	const colors = shouldColor ? Colors : NoColors;
+	let color = LevelColors[type] || colors.white;
+	if (!shouldColor) {
+		color = (v) => v;
+	}
 	const levelText = levelShort[type] || type.toUpperCase().slice(0, 4); // Get first 4 chars, consistent uppercase
 
 	let line = '';
@@ -72,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));
 
@@ -151,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

@@ -0,0 +1,40 @@
+import dayjs from 'dayjs';
+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);
+dayjs.extend(duration);
+dayjs.extend(isBetween);
+dayjs.extend(isSameOrAfter);
+dayjs.extend(isSameOrBefore);
+dayjs.extend(isToday);
+dayjs.extend(isTomorrow);
+dayjs.extend(isYesterday);
+dayjs.extend(localeData);
+dayjs.extend(objectSupport);
+dayjs.extend(quarterOfYear);
+dayjs.extend(relativeTime);
+dayjs.extend(timezone);
+dayjs.extend(toObject);
+dayjs.extend(utc);
+dayjs.locale('zh-cn');
+dayjs.tz.setDefault('Asia/Shanghai');
+
+export { dayjs };

package/src/dayjs/formatDuration.test.ts

@@ -0,0 +1,14 @@
+import { expect, test } from 'vitest';
+import { formatDuration } from './formatDuration';
+
+test('formatDuration', () => {
+	for (const [a, b] of [
+		[0, '0ms'],
+		[1000, '1s'],
+		[1000 * 60, '1m'],
+		[1000 * 60 + 1000, '1m1s'],
+		[1000 * 60 + 1000 + 1, '1m1s1ms'],
+	]) {
+		expect(formatDuration(a)).toBe(b);
+	}
+});

package/src/dayjs/formatDuration.ts

@@ -0,0 +1,86 @@
+import { type OpUnitType, type UnitTypeLongPlural } from 'dayjs';
+import { type Duration } from 'dayjs/plugin/duration';
+import { parseDuration } from './parseDuration';
+
+type FormatDurationOptions = {
+	humanize?: boolean;
+	format?: string | 'human' | 'humanize' | 'iso' | 'auto';
+	iso?: boolean;
+};
+
+export type MaybeDuration =
+	| number
+	| string
+	| Duration
+	| Partial<{
+			[unit in Exclude<UnitTypeLongPlural, 'dates'> | 'weeks']: number;
+	  }>
+	| {
+			value: number;
+			unit?: Exclude<OpUnitType, 'date' | 'dates'>;
+	  }
+	| undefined
+	| null;
+
+export function formatDuration(value: MaybeDuration, o?: FormatDurationOptions): string | undefined {
+	const v = parseDuration(value);
+	if (v === undefined || v === null) {
+		return;
+	}
+
+	let { format, humanize, iso } = o || {};
+	// Use local variables instead of modifying o directly
+	switch (format) {
+		case 'human':
+		case 'humanize':
+			humanize = true;
+			format = undefined;
+			break;
+		case 'iso':
+			iso = true;
+			format = undefined;
+			break;
+		case 'auto':
+			format = undefined;
+			break;
+	}
+
+	if (humanize) {
+		return v.humanize();
+	}
+	if (iso) {
+		return v.toISOString();
+	}
+	if (format) {
+		return v.format(format);
+	}
+
+	// auto format
+	// 1h2m3s
+	if (v.asDays() > 1) {
+		let s = v.toISOString();
+		return s.replace('P', '').replace('T', '').toLowerCase();
+	}
+
+	{
+		let parts: string[] = [];
+		let h = v.hours();
+		let m = v.minutes();
+		let s = v.seconds();
+		let ms = v.milliseconds();
+
+		if (h > 0) {
+			parts.push(`${h}h`);
+		}
+		if (m > 0) {
+			parts.push(`${m}m`);
+		}
+		if (s > 0) {
+			parts.push(`${s}s`);
+		}
+		if (ms > 0 || (h === 0 && m === 0 && s === 0)) {
+			parts.push(`${ms}ms`);
+		}
+		return parts.join('');
+	}
+}

package/src/dayjs/index.ts

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

package/src/dayjs/parseDuration.ts

@@ -0,0 +1,40 @@
+import type { OpUnitType, UnitTypeLongPlural } from 'dayjs';
+import type { Duration } from 'dayjs/plugin/duration';
+import { dayjs } from './dayjs';
+
+export type MaybeDuration =
+	| number
+	| string
+	| Duration
+	| Partial<{
+			[unit in Exclude<UnitTypeLongPlural, 'dates'> | 'weeks']: number;
+	  }>
+	| {
+			value: number;
+			unit?: Exclude<OpUnitType, 'date' | 'dates'>;
+	  }
+	| undefined
+	| null;
+
+export function parseDuration(value: MaybeDuration): Duration | undefined {
+	if (!value && value !== 0) {
+		return;
+	}
+	let duration: Duration;
+	if (typeof value === 'number') {
+		duration = dayjs.duration(value);
+	} else if (typeof value === 'string' && value.startsWith('P')) {
+		// PT0S
+		duration = dayjs.duration(value);
+	} else if (typeof value === 'object' && 'value' in value) {
+		duration = dayjs.duration(value.value, value.unit);
+	} else if (dayjs.isDuration(value)) {
+		duration = value;
+	} else if (typeof value === 'object') {
+		duration = dayjs.duration(value);
+	} else {
+		console.warn(`Invalid duration value:`, value);
+		return;
+	}
+	return duration;
+}

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 }),
+		});
+	});
+});