@wener/common 2.0.1 → 2.0.2

package/src/cn/__snapshots__/UnifiedSocialCreditCode.test.ts.snap

@@ -2,40 +2,46 @@
 
 exports[`UnifiedSocialCreditCode > should parse 1`] = `
 {
-  "bureau": "9",
-  "checksum": "P",
+  "adminDivisionCode": "330106",
+  "checkDigit": "P",
   "codes": [
     "9",
     "1",
     "330106",
     "673959654",
+    "P",
   ],
-  "division": "330106",
-  "labels": [
+  "entityCategoryCode": "1",
+  "names": [
     "工商",
     "企业",
   ],
-  "subject": "673959654",
-  "subjectType": "1",
+  "organizationCode": "673959654",
+  "raw": "91330106673959654P",
+  "registrationAuthorityCode": "9",
+  "valid": true,
 }
 `;
 
 exports[`UnifiedSocialCreditCode > should parse 2`] = `
 {
-  "bureau": "9",
-  "checksum": "R",
+  "adminDivisionCode": "330106",
+  "checkDigit": "R",
   "codes": [
     "9",
     "1",
     "330106",
     "MA2CFLDG4",
+    "R",
   ],
-  "division": "330106",
-  "labels": [
+  "entityCategoryCode": "1",
+  "names": [
     "工商",
     "企业",
   ],
-  "subject": "MA2CFLDG4",
-  "subjectType": "1",
+  "organizationCode": "MA2CFLDG4",
+  "raw": "91330106MA2CFLDG4R",
+  "registrationAuthorityCode": "9",
+  "valid": true,
 }
 `;

package/src/cn/index.ts

@@ -1,3 +1 @@
-export { ResidentIdentityCardNumber } from './ResidentIdentityCardNumber';
-export { DivisionCode } from './DivisionCode';
-export { UnifiedSocialCreditCode } from './UnifiedSocialCreditCode';
+export { ChineseResidentIdNo, UnifiedSocialCreditCode, DivisionCode } from './mod';

package/src/cn/mod.ts

@@ -0,0 +1,3 @@
+export * as ChineseResidentIdNo from './ChineseResidentIdNo.mod';
+export * as UnifiedSocialCreditCode from './UnifiedSocialCreditCode.mod';
+export * as DivisionCode from './DivisionCode.mod';

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 = '';

package/src/dayjs/dayjs.ts

@@ -0,0 +1,40 @@
+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';
+
+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,3 @@
+export { dayjs } from './dayjs';
+export { parseDuration } from './parseDuration';
+export { formatDuration } from './formatDuration';

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/decimal/index.ts

@@ -0,0 +1 @@
+export { parseDecimal } from './parseDecimal';

package/src/decimal/parseDecimal.ts

@@ -0,0 +1,16 @@
+import Decimal from 'decimal.js';
+
+export function parseDecimal(v: string | number | Decimal): Decimal;
+export function parseDecimal(v: string | number | Decimal | undefined | null): Decimal | undefined;
+export function parseDecimal(v: string | number | Decimal | undefined | null): Decimal | undefined {
+	switch (v) {
+		case '':
+		case undefined:
+		case null:
+			return undefined;
+	}
+	if (Decimal.isDecimal(v)) {
+		return v;
+	}
+	return new Decimal(v);
+}

package/src/foundation/schema/SexType.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod/v4';
+import type { EnumValues } from '../../resource/schema';
+
+// Sex 指的是生理性别/生物性别，通常由出生时的生物特征决定
+export const SexType = Object.freeze({
+	__proto__: null,
+	Male: 'Male',
+	Female: 'Female',
+});
+export type SexType = EnumValues<typeof SexType>;
+
+export const SexTypeSchema = z
+	.union([
+		//
+		z.literal(SexType.Male).describe('男'),
+		z.literal(SexType.Female).describe('女'),
+	])
+	.describe('性别')
+	.meta({
+		title: 'SexType',
+	});

package/src/foundation/schema/index.ts

@@ -0,0 +1 @@
+export { SexType, SexTypeSchema } from './SexType';

package/src/foundation/schema/parseSexType.ts

@@ -0,0 +1,19 @@
+import { SexType } from './SexType';
+
+export function parseSexType(s: string | null | undefined): undefined | SexType {
+	if (!s) return undefined;
+
+	switch (s.toLowerCase()) {
+		case '♂':
+		case '男':
+		case 'male':
+		case 'man':
+			return SexType.Male;
+		case '♀':
+		case '女':
+		case 'female':
+		case 'woman':
+			return SexType.Female;
+	}
+	return undefined;
+}

package/src/foundation/schema/types.ts

@@ -0,0 +1,8 @@
+import z from 'zod/v4';
+
+export const CoordinatesSchema = z
+	.object({
+		latitude: z.number().min(-90).max(90).describe('纬度'),
+		longitude: z.number().min(-180).max(180).describe('经度'),
+	})
+	.describe('坐标信息');

package/src/password/Password.ts

@@ -68,10 +68,10 @@ export namespace Password {
 		return f;
 	}
 
-	export async function check(password: string, hash: string) {
+	export async function validate(password: string, hash: string) {
 		let res = await parse(hash);
 		let f = resolveAlgorithm(res.id);
-		return { result: f.verify(password, hash, res), parsed: res };
+		return { result: await f.verify(password, hash, res), parsed: res };
 	}
 
 	export async function verify(password: string, hash: string) {

package/src/resource/ListQuery.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod/v4';
+
+export type ListQueryInput = z.input<typeof ListQuerySchema>;
+export type ListQuery = z.infer<typeof ListQuerySchema>;
+const IntLikeSchema = z.coerce
+	.number()
+	.multipleOf(1)
+	.min(0)
+	.optional()
+	.overwrite((v) => v || undefined);
+export const ListQuerySchema = z.object({
+	id: z.coerce.string().optional(),
+	ids: z.array(z.coerce.string()).optional(),
+	filter: z.string().optional().describe('sql-like filter string'),
+	filters: z.array(z.any()).optional().describe('sql-like filter string'),
+	where: z.record(z.string(), z.any()).optional().describe('document query filter'),
+	search: z.string().optional(),
+	limit: IntLikeSchema,
+	offset: IntLikeSchema,
+	order: z.array(z.string()).optional().describe('order like "a,-b,c desc null last"'),
+	pageIndex: IntLikeSchema.describe('0-based page index'),
+	pageNumber: IntLikeSchema.describe('1-based page number'),
+	pageSize: IntLikeSchema,
+	cursor: z.string().optional(),
+	deleted: z.coerce.boolean().optional(),
+});
+
+type ListQueryOverride = ListQueryInput | undefined | ((input: ListQueryInput) => ListQueryInput | undefined | void);
+
+export function resolveListQuery(target: ListQueryInput | undefined, ...args: ListQueryOverride[]): ListQuery {
+	let out = args.reduce((a: ListQueryInput, source) => {
+		if (typeof source === 'function') {
+			const result = source(a);
+			// do not use the result as merge source
+			return result || a;
+		}
+
+		let b: ListQueryInput | undefined = source;
+		if (!b) return a;
+
+		// do not resolve id to ids
+		let ids = [...(a.ids || []), ...(b.ids || [])];
+		return {
+			...a,
+			...b,
+			ids: ids,
+			filters: [...(a.filters || []), ...(b.filters || [])],
+			search: b.search || a.search,
+			// NOTE maybe should merge where ?
+		};
+	}, target || {});
+	return ListQuerySchema.parse(out);
+}

package/src/resource/index.ts

@@ -1,3 +1,4 @@
 export { type AnyResource } from './schema/AnyResourceSchema';
 export { type Identifiable } from './Identifiable';
 export { getTitleOfResource } from './getTitleOfResource';
+export { type ListQueryInput, type ListQuery, resolveListQuery, ListQuerySchema } from './ListQuery';

package/src/resource/schema/AnyResourceSchema.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod/v4';
-import { SexTypeSchema } from './SexType';
+import { SexTypeSchema } from '../../foundation/schema/SexType';
 import { rz } from './types';
 
 export type AnyResource = z.infer<typeof AnyResourceSchema>;

package/src/resource/schema/index.ts

@@ -0,0 +1,5 @@
+export { ResourceStatus, ResourceStatusSchema } from './ResourceStatus';
+export { ResourceActionType, ResourceActionTypeSchema, ResourceActionDataSchema } from './ResourceActionType';
+export { AnyResourceSchema, type AnyResource } from './AnyResourceSchema';
+export { rz, type EnumValues } from './types';
+export { BaseResourceSchema } from './BaseResourceSchema';

package/src/schema/SchemaRegistry.mod.ts

@@ -0,0 +1 @@
+export * as SchemaRegistry from './SchemaRegistry';

package/src/{resource/schema → schema}/SchemaRegistry.ts

@@ -1,6 +1,6 @@
 import { getGlobalStates } from '@wener/utils';
-import type { JsonSchemaDef } from '../../jsonschema';
-import { toJsonSchema, type SchemaOutput, type TypeSchema } from '../../schema';
+import type { JsonSchemaDef } from '../jsonschema';
+import { toJsonSchema, type SchemaOutput, type TypeSchema } from './index';
 
 const types = getGlobalStates('@wener/common/resource/schema/SchemaRegistry', () => new Map<string, JsonSchemaDef>());
 
@@ -12,7 +12,7 @@ export function get(needle: TypeSchema | string) {
 	if (found) {
 		return found;
 	} else {
-		if (typeof needle !== 'string') {
+		if (needle && typeof needle !== 'string') {
 			return toJsonSchema(needle);
 		}
 	}
@@ -33,10 +33,14 @@ function getKey(s: TypeSchema | string) {
 	return key;
 }
 
-export function add(def: TypeSchema) {
-	types.set(getKey(def), toJsonSchema(def));
-}
-
-export function set(key: TypeSchema | string, def: TypeSchema) {
+export function set(key: TypeSchema | string, def: TypeSchema): void;
+export function set(key: TypeSchema, def?: TypeSchema): void;
+export function set(key: TypeSchema | string, def?: TypeSchema) {
+	if (!def) {
+		def = key as TypeSchema;
+		if (!def || typeof def !== 'object') {
+			throw new Error(`Invalid schema definition for: ${getKey(key)}`);
+		}
+	}
 	types.set(getKey(key), toJsonSchema(def));
 }

package/src/schema/createSchemaData.ts

@@ -59,7 +59,7 @@ function _create(schema: JsonSchemaDef, options: CreateOptions, ctx: { required:
 		.with({ type: 'object' }, () => {
 			const out: Record<string, any> = {};
 
-			let required = schema.required || [];
+			let required = Array.isArray(schema.required) ? schema.required : [];
 			for (const [k, v] of Object.entries(schema.properties || {}) as [string, JsonSchemaDef][]) {
 				const value = _create(v, options, {
 					required: required.includes(k),

package/src/schema/getSchemaOptions.ts

@@ -1,10 +1,10 @@
 import { deepFreeze } from '@wener/utils';
 import { getSchemaCache } from './getSchemaCache';
-import { toJsonSchema } from './toJsonSchema';
+import { SchemaRegistry } from './SchemaRegistry.mod';
 import type { TypeSchema } from './TypeSchema';
 
 export function getSchemaOptions(s: TypeSchema): Array<{ value: string; label: string }> {
-	let js = toJsonSchema(s);
+	let js = SchemaRegistry.get(s);
 	return getSchemaCache(s, 'options', () => {
 		let out =
 			(js.anyOf || js.oneOf)?.map((v) => {

package/src/schema/index.ts

@@ -4,3 +4,4 @@ export { getSchemaOptions, getSchemaOptionLabel } from './getSchemaOptions';
 export { toJsonSchema } from './toJsonSchema';
 export { findJsonSchemaByPath } from './findJsonSchemaByPath';
 export { createSchemaData } from './createSchemaData';
+export { SchemaRegistry } from './SchemaRegistry.mod';

package/src/utils/getEstimateProcessTime.ts

@@ -0,0 +1,36 @@
+type EstimateProcessTimeResult = {
+	eta: number; // estimated time of arrival in seconds
+	elapsed: number; // in seconds
+	endTime: Date; // estimated end time
+	rate: number; // rate of processing in items per second
+};
+
+export function getEstimateProcessTime({
+	total,
+	processed,
+	startTime,
+	elapsed = startTime ? (Date.now() - startTime.getTime()) / 1000 : undefined,
+}: {
+	total?: number;
+	processed?: number;
+	startTime?: Date;
+	elapsed?: number; // in seconds
+}): EstimateProcessTimeResult | undefined {
+	if (typeof total !== 'number' || typeof processed !== 'number' || !elapsed || processed === 0 || processed >= total) {
+		return undefined;
+	}
+	const now = new Date();
+	const rate = processed / elapsed;
+	if (rate === 0) {
+		return undefined;
+	}
+	const remaining = total - processed;
+	const eta = Math.round(remaining / rate);
+	const endTime = new Date(now.getTime() + eta * 1000);
+	return {
+		eta,
+		elapsed,
+		endTime,
+		rate,
+	};
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export { getEstimateProcessTime } from './getEstimateProcessTime';

package/lib/cn/ResidentIdentityCardNumber.js

@@ -1,50 +0,0 @@
-import { formatDate } from "./formatDate.js";
-import { Mod11Checksum } from "./Mod11Checksum.js";
-(function (ResidentIdentityCardNumber) {
-    ResidentIdentityCardNumber.Checksum = new Mod11Checksum();
-    function parse(s) {
-        var division = s.slice(0, 6);
-        var birthDate = s.slice(6, 14);
-        var sequence = parseInt(s.slice(14, 17), 10);
-        var checksum = s.slice(17, 18);
-        var valid = ResidentIdentityCardNumber.Checksum.validate(s);
-        var sex = sequence % 2 === 1 ? "Male" : "Female";
-        return {
-            division: division,
-            birthDate: birthDate,
-            sequence: sequence,
-            checksum: checksum,
-            valid: valid,
-            sex: sex,
-            male: sex === "Male",
-            female: sex === "Female",
-            age: new Date().getFullYear() - parseInt(birthDate.slice(0, 4), 10)
-        };
-    }
-    /*
-  export const length = 18;
-  export const pattern = /^\d{6}(18|19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}[0-9Xx]$/;
-   */ ResidentIdentityCardNumber.parse = parse;
-    function format(param) {
-        var division = param.division, birthDate = param.birthDate, sequence = param.sequence, checksum = param.checksum;
-        if (typeof birthDate !== "string") {
-            birthDate = formatDate(birthDate, "yyyyMMDD");
-        }
-        if (birthDate.includes("-")) {
-            birthDate = birthDate.replace(/-/g, "");
-        }
-        typeof sequence === "number" && (sequence = sequence.toString());
-        sequence = sequence.padStart(3, "0");
-        var base = [
-            division,
-            birthDate,
-            sequence
-        ].join("");
-        if (base.length !== 17)
-            throw new Error("Invalid params");
-        checksum || (checksum = ResidentIdentityCardNumber.Checksum.compute(base));
-        return base + checksum;
-    }
-    ResidentIdentityCardNumber.format = format;
-})(ResidentIdentityCardNumber || (ResidentIdentityCardNumber = {}));
-export var ResidentIdentityCardNumber;

package/lib/cn/formatDate.js

@@ -1,13 +0,0 @@
-export function formatDate(date, format) {
-    switch(format){
-        case 'yyyyMMDD':
-            {
-                var year = date.getFullYear();
-                var month = (date.getMonth() + 1).toString().padStart(2, '0');
-                var day = date.getDate().toString().padStart(2, '0');
-                return "".concat(year).concat(month).concat(day);
-            }
-        default:
-            throw new Error("Invalid format");
-    }
-}

package/lib/cn/parseSex.js

@@ -1,20 +0,0 @@
-export function parseSex(s) {
-    if (!s) return undefined;
-    switch(s.toLowerCase()){
-        case '男':
-        case 'male':
-            return {
-                sex: 'Male',
-                male: true,
-                female: false
-            };
-        case '女':
-        case 'female':
-            return {
-                sex: 'Female',
-                male: false,
-                female: true
-            };
-    }
-    return undefined;
-}