@wener/common 1.0.3 → 1.0.4

package/src/cn/UnifiedSocialCreditCode.test.ts

@@ -2,15 +2,15 @@ import { describe, expect, it } from 'vitest';
 import { UnifiedSocialCreditCode } from './UnifiedSocialCreditCode';
 
 describe('UnifiedSocialCreditCode', () => {
-  it('should parse', () => {
-    for (const a of [
-      //
-      '91330106673959654P',
-      '91330106MA2CFLDG4R',
-    ]) {
-      let out = UnifiedSocialCreditCode.parse(a);
-      expect(UnifiedSocialCreditCode.format(out)).toBe(a);
-      expect(out).toMatchSnapshot();
-    }
-  });
+	it('should parse', () => {
+		for (const a of [
+			//
+			'91330106673959654P',
+			'91330106MA2CFLDG4R',
+		]) {
+			let out = UnifiedSocialCreditCode.parse(a);
+			expect(UnifiedSocialCreditCode.format(out)).toBe(a);
+			expect(out).toMatchSnapshot();
+		}
+	});
 });

package/src/cn/UnifiedSocialCreditCode.ts

@@ -6,143 +6,138 @@ import { Mod31Checksum } from './Mod31Checksum';
  * - GB 11714-1997 全国组织机构代码编制规则
  */
 export namespace UnifiedSocialCreditCode {
-  interface CodeValue {
-    label: string;
-    children?: Record<string, CodeValue>;
-  }
+	interface CodeValue {
+		label: string;
+		children?: Record<string, CodeValue>;
+	}
 
-  const CodeLabels: Record<string, CodeValue> = {
-    1: {
-      label: '机构编制',
-      children: {
-        1: { label: '机关' },
-        2: { label: '事业单位' },
-        3: { label: '中央编办直接管理机构编制的群众团体' },
-        9: { label: '其他' },
-      },
-    },
-    5: {
-      label: '民政',
-      children: {
-        1: { label: '社会团体' },
-        2: { label: '民办非企业单位' },
-        3: { label: '基金会' },
-        9: { label: '其他' },
-      },
-    },
-    9: {
-      label: '工商',
-      children: {
-        1: { label: '企业' },
-        2: { label: '个体工商户' },
-        3: { label: '农民专业合作社' },
-        9: { label: '其他' },
-      },
-    },
-    Y: {
-      label: '其他',
-      children: {
-        1: { label: '其他' },
-      },
-    },
-  };
+	const CodeLabels: Record<string, CodeValue> = {
+		1: {
+			label: '机构编制',
+			children: {
+				1: { label: '机关' },
+				2: { label: '事业单位' },
+				3: { label: '中央编办直接管理机构编制的群众团体' },
+				9: { label: '其他' },
+			},
+		},
+		5: {
+			label: '民政',
+			children: {
+				1: { label: '社会团体' },
+				2: { label: '民办非企业单位' },
+				3: { label: '基金会' },
+				9: { label: '其他' },
+			},
+		},
+		9: {
+			label: '工商',
+			children: {
+				1: { label: '企业' },
+				2: { label: '个体工商户' },
+				3: { label: '农民专业合作社' },
+				9: { label: '其他' },
+			},
+		},
+		Y: { label: '其他', children: { 1: { label: '其他' } } },
+	};
 
-  export const pattern = /^([159][1239]|Y1)[0-9]{6}[0-9A-HJ-NP-RTUWXY]{10}$/; // 无 I O Z S V
+	export const pattern = /^([159][1239]|Y1)[0-9]{6}[0-9A-HJ-NP-RTUWXY]{10}$/; // 无 I O Z S V
 
-  export const Checksum = new Mod31Checksum();
+	export const Checksum = new Mod31Checksum();
 
-  export function parse(s: string): ParsedUnifiedSocialCreditCode {
-    let bureau = s[0];
-    let subjectType = s[1];
-    let division = s.slice(2, 8); // 第3~8位，共6位，正确
-    let subject = s.slice(8, 17); // 第9~17位，共9位
-    let checksum = s.slice(17, 18); // 第18位，校验码
+	export function parse(s: string): ParsedUnifiedSocialCreditCode {
+		let bureau = s[0];
+		let subjectType = s[1];
+		let division = s.slice(2, 8); // 第3~8位，共6位，正确
+		let subject = s.slice(8, 17); // 第9~17位，共9位
+		let checksum = s.slice(17, 18); // 第18位，校验码
 
-    const labels: string[] = [];
-    let l1 = CodeLabels[bureau];
-    l1 && labels.push(l1?.label);
-    let l2 = l1?.children?.[subjectType];
-    l2 && labels.push(l2?.label);
+		const labels: string[] = [];
+		let l1 = CodeLabels[bureau];
+		l1 && labels.push(l1?.label);
+		let l2 = l1?.children?.[subjectType];
+		l2 && labels.push(l2?.label);
 
-    return {
-      bureau,
-      subjectType,
-      division,
-      subject,
-      checksum,
-      codes: [bureau, subjectType, division, subject],
-      labels,
-    };
-  }
+		return {
+			bureau,
+			subjectType,
+			division,
+			subject,
+			checksum,
+			codes: [bureau, subjectType, division, subject],
+			labels,
+		};
+	}
 
-  export function format({
-    bureau,
-    subjectType,
-    division,
-    subject,
-    checksum,
-  }: {
-    bureau: string;
-    subjectType: string;
-    division: string;
-    subject: string;
-    checksum?: string;
-  }): string {
-    const base = `${bureau}${subjectType}${division}${subject}`;
-    checksum ||= Checksum.compute(base);
-    return `${base}${checksum}`;
-  }
+	export function format({
+		bureau,
+		subjectType,
+		division,
+		subject,
+		checksum,
+	}: {
+		bureau: string;
+		subjectType: string;
+		division: string;
+		subject: string;
+		checksum?: string;
+	}): string {
+		const base = `${bureau}${subjectType}${division}${subject}`;
+		checksum ||= Checksum.compute(base);
+		return `${base}${checksum}`;
+	}
 
-  export function next(s: string, delta: number = 1) {
-    const sp = s.split('').map((v) => Checksum.numbers[v]);
-    for (let i = sp.length - 1; i >= 0; i--) {
-      if ((delta > 0 && sp[i] < 30) || (delta < 0 && sp[i] > 0)) {
-        sp[i] += delta;
-        break;
-      } else if (delta > 0 && sp[i] === 30) {
-        sp[i] = 0;
-      } else if (delta < 0 && sp[i] === 0) {
-        sp[i] = 30;
-      }
-    }
-    return sp.map((v) => Checksum.chars[v]).join('');
-  }
+	export function next(s: string, delta: number = 1) {
+		const sp = s.split('').map((v) => Checksum.numbers[v]);
+		for (let i = sp.length - 1; i >= 0; i--) {
+			if ((delta > 0 && sp[i] < 30) || (delta < 0 && sp[i] > 0)) {
+				sp[i] += delta;
+				break;
+			} else if (delta > 0 && sp[i] === 30) {
+				sp[i] = 0;
+			} else if (delta < 0 && sp[i] === 0) {
+				sp[i] = 30;
+			}
+		}
+		return sp.map((v) => Checksum.chars[v]).join('');
+	}
 }
 
 /**
  * 解析后的统一社会信用代码信息
  */
 interface ParsedUnifiedSocialCreditCode {
-  /**
-   * @title 登记管理部门代码
-   * 对应统一社会信用代码的第1位字符，用于标识发证机构类别（登记管理部门）。
-   */
-  bureau: string;
+	/**
+	 * @title 登记管理部门代码
+	 * 对应统一社会信用代码的第1位字符，用于标识发证机构类别（登记管理部门）。
+	 */
+	bureau: string;
 
-  /**
-   * @title 机构类别代码
-   * 对应统一社会信用代码的第2位字符，用于标识被赋码主体的类型（如企业、事业单位、社会组织等）。
-   */
-  subjectType: string;
+	/**
+	 * @title 机构类别代码
+	 * 对应统一社会信用代码的第2位字符，用于标识被赋码主体的类型（如企业、事业单位、社会组织等）。
+	 */
+	subjectType: string;
 
-  /**
-   * @title 登记管理机关行政区划代码
-   * 对应统一社会信用代码的第3至第8位字符，用于标识该主体登记机关所在的行政区划。
-   */
-  division: string;
+	/**
+	 * @title 登记管理机关行政区划代码
+	 * 对应统一社会信用代码的第3至第8位字符，用于标识该主体登记机关所在的行政区划。
+	 */
+	division: string;
 
-  /**
-   * @title 主体标识码
-   * 对应统一社会信用代码的第9至第17位字符，用于标识特定的市场主体或法人单位。
-   */
-  subject: string;
+	/**
+	 * @title 主体标识码
+	 * 对应统一社会信用代码的第9至第17位字符，用于标识特定的市场主体或法人单位。
+	 */
+	subject: string;
 
-  /**
-   * @title 校验码
-   * 对应统一社会信用代码的最后一位字符，用特定算法计算，用于校验代码有效性。
-   */
-  checksum: string;
+	/**
+	 * @title 校验码
+	 * 对应统一社会信用代码的最后一位字符，用特定算法计算，用于校验代码有效性。
+	 */
+	checksum: string;
 
-  codes: string[];
-  labels: string[];
+	codes: string[];
+	labels: string[];
 }

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

@@ -2,7 +2,7 @@
 
 exports[`ResidentIdentityCardNumber > should parse 1`] = `
 {
-  "age": 75,
+  "age": 76,
   "birthDate": "19491231",
   "checksum": "X",
   "division": "110105",

package/src/cn/formatDate.ts

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

package/src/cn/parseSex.ts

@@ -1,27 +1,13 @@
-export function parseSex(s: string):
-  | undefined
-  | {
-      sex: 'Male' | 'Female';
-      male: boolean;
-      female: boolean;
-    } {
-  if (!s) return undefined;
+export function parseSex(s: string): undefined | { sex: 'Male' | 'Female'; male: boolean; female: boolean } {
+	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;
+	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;
 }

package/src/cn/types.d.ts

@@ -5,47 +5,47 @@
  * @see https://en.wikipedia.org/wiki/Foreign_Permanent_Resident_ID_Card
  */
 export interface ResidentIdentityCardInfo {
-  /**
-   * @title 姓名
-   */
-  name: string;
-  /**
-   * @title 性别
-   */
-  sex: 'Male' | 'Female';
-  /**
-   * @title 民族
-   * 例如 '汉'/'满'/'回'
-   */
-  ethnicity: string;
-  /**
-   * @title 出生日期
-   * @format date
-   */
-  birthDate: string;
-  /**
-   * @title 地址
-   *
-   * - 通常为 domicile/户籍地
-   */
-  address: string;
-  /**
-   * @title 身份证号
-   */
-  identityCardNumber: string;
-  /**
-   * @title 签发机关
-   */
-  issuer: string;
-  /**
-   * @title 有效期开始日期
-   * @format date
-   */
-  validStartDate: string;
-  /**
-   * @title 有效期结束日期
-   * @format date
-   * @description 如长期有效则为 空
-   */
-  validEndDate?: string;
+	/**
+	 * @title 姓名
+	 */
+	name: string;
+	/**
+	 * @title 性别
+	 */
+	sex: 'Male' | 'Female';
+	/**
+	 * @title 民族
+	 * 例如 '汉'/'满'/'回'
+	 */
+	ethnicity: string;
+	/**
+	 * @title 出生日期
+	 * @format date
+	 */
+	birthDate: string;
+	/**
+	 * @title 地址
+	 *
+	 * - 通常为 domicile/户籍地
+	 */
+	address: string;
+	/**
+	 * @title 身份证号
+	 */
+	identityCardNumber: string;
+	/**
+	 * @title 签发机关
+	 */
+	issuer: string;
+	/**
+	 * @title 有效期开始日期
+	 * @format date
+	 */
+	validStartDate: string;
+	/**
+	 * @title 有效期结束日期
+	 * @format date
+	 * @description 如长期有效则为 空
+	 */
+	validEndDate?: string;
 }

package/src/data/formatSort.test.ts

@@ -0,0 +1,13 @@
+import { expect, test } from 'vitest';
+import { formatSort } from './formatSort';
+
+test('formatSort', () => {
+	expect(formatSort([{ field: 'name', order: 'asc' }])).toEqual(['name asc']);
+	expect(formatSort([{ field: 'age', order: 'desc', nulls: 'last' }])).toEqual(['age desc nulls last']);
+	expect(
+		formatSort([
+			{ field: 'name', order: 'asc' },
+			{ field: 'age', order: 'desc' },
+		]),
+	).toEqual(['name asc', 'age desc']);
+});

package/src/data/formatSort.ts

@@ -0,0 +1,18 @@
+import type { SortRule } from './parseSort';
+
+export function formatSort(s: SortRule[]): string[] {
+	return s
+		.map(({ field, order, nulls }) => {
+			if (!field) return '';
+
+			let r = field;
+			if (order) {
+				r += ` ${order}`;
+			}
+			if (nulls) {
+				r += ` nulls ${nulls}`;
+			}
+			return r;
+		})
+		.filter(Boolean);
+}

package/src/data/index.ts

@@ -0,0 +1,5 @@
+export type * from './types';
+
+export { resolvePagination, type PaginationInput, type ResolvedPagination } from './resolvePagination';
+export { parseSort, type SortRule } from './parseSort';
+export { formatSort } from './formatSort';

package/src/data/maybeNumber.ts

@@ -0,0 +1,23 @@
+export type MaybeNumber = number | null | string | undefined | bigint;
+
+export function maybeNumber(v: MaybeNumber) {
+	if (v === null || v === undefined) {
+		return undefined;
+	}
+
+	switch (typeof v) {
+		case 'number':
+			return v;
+		case 'bigint':
+			return Number(v);
+		case 'string':
+			if (v === '') {
+				return undefined;
+			}
+	}
+	const n = Number(v);
+	if (isNaN(n)) {
+		return undefined;
+	}
+	return n;
+}

package/src/data/parseSort.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, test } from 'vitest';
+import { formatSort } from './formatSort';
+import { parseSort } from './parseSort';
+
+describe('parseSort', () => {
+	describe('basic parsing', () => {
+		test('handles empty inputs', () => {
+			expect(parseSort('')).toEqual([]);
+			expect(parseSort([])).toEqual([]);
+			expect(parseSort(null)).toEqual([]);
+			expect(parseSort(undefined)).toEqual([]);
+		});
+
+		test('handles simple field names', () => {
+			expect(parseSort('a')).toEqual([{ field: 'a', order: 'asc' }]);
+			expect(parseSort(['a'])).toEqual([{ field: 'a', order: 'asc' }]);
+			expect(parseSort('a.b')).toEqual([{ field: 'a.b', order: 'asc' }]);
+		});
+
+		test('handles prefix notation', () => {
+			expect(parseSort('-a')).toEqual([{ field: 'a', order: 'desc' }]);
+			expect(parseSort('+b')).toEqual([{ field: 'b', order: 'asc' }]);
+			expect(parseSort('-a,+b')).toEqual([
+				{ field: 'a', order: 'desc' },
+				{ field: 'b', order: 'asc' },
+			]);
+		});
+	});
+
+	describe('explicit ordering', () => {
+		test('handles explicit order keywords', () => {
+			expect(parseSort('a asc')).toEqual([{ field: 'a', order: 'asc' }]);
+			expect(parseSort('a desc')).toEqual([{ field: 'a', order: 'desc' }]);
+			expect(parseSort('-a asc')).toEqual([{ field: 'a', order: 'asc' }]); // explicit order overrides prefix
+		});
+	});
+
+	describe('nulls handling', () => {
+		test('handles nulls specification', () => {
+			expect(parseSort('a asc nulls last')).toEqual([{ field: 'a', order: 'asc', nulls: 'last' }]);
+			expect(parseSort('a asc nulls first')).toEqual([{ field: 'a', order: 'asc', nulls: 'first' }]);
+			expect(parseSort('a desc nulls last')).toEqual([{ field: 'a', order: 'desc', nulls: 'last' }]);
+			expect(parseSort('a nulls first')).toEqual([{ field: 'a', order: 'asc', nulls: 'first' }]);
+			expect(parseSort('-a nulls first')).toEqual([{ field: 'a', order: 'desc', nulls: 'first' }]);
+
+			// Alternative syntax
+			expect(parseSort('a asc last')).toEqual([{ field: 'a', order: 'asc', nulls: 'last' }]);
+		});
+	});
+
+	describe('object notation', () => {
+		test('handles object input', () => {
+			expect(parseSort([{ field: 'a', order: 'asc' }])).toEqual([{ field: 'a', order: 'asc' }]);
+			expect(parseSort([{ field: 'a', order: 'asc', nulls: 'last' }])).toEqual([
+				{ field: 'a', order: 'asc', nulls: 'last' },
+			]);
+		});
+	});
+
+	describe('invalid inputs', () => {
+		test('handles invalid inputs gracefully', () => {
+			expect(parseSort([{ order: 'asc' }])).toEqual([]);
+			expect(parseSort(['a,,', { field: '', order: 'asc' }])).toEqual([{ field: 'a', order: 'asc' }]);
+			expect(parseSort([',,', { field: 'a', order: 'asc' }])).toEqual([{ field: 'a', order: 'asc' }]);
+		});
+	});
+});