@wener/common 2.0.1 → 2.0.3

package/lib/search/types.d.js

@@ -1 +0,0 @@
-export { };

package/src/cn/ResidentIdentityCardNumber.test.ts

@@ -1,17 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ResidentIdentityCardNumber } from './ResidentIdentityCardNumber';
-
-describe('ResidentIdentityCardNumber', () => {
-	it('should parse', () => {
-		for (const a of ['11010519491231002X']) {
-			let out = ResidentIdentityCardNumber.parse(a);
-			expect(ResidentIdentityCardNumber.format(out)).toBe(a);
-			expect(out).toMatchSnapshot();
-		}
-	});
-	it('should format with partial', () => {
-		expect(
-			ResidentIdentityCardNumber.format({ division: '110105', birthDate: new Date('1949-12-31'), sequence: 2 }),
-		).toBe('11010519491231002X');
-	});
-});

package/src/cn/ResidentIdentityCardNumber.ts

@@ -1,96 +0,0 @@
-import { formatDate } from './formatDate';
-import { Mod11Checksum } from './Mod11Checksum';
-
-export namespace ResidentIdentityCardNumber {
-	export const Checksum = new Mod11Checksum();
-
-	/*
-  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]$/;
-   */
-
-	export function parse(s: string): ParsedResidentIdentityCardNumber {
-		const division = s.slice(0, 6);
-		const birthDate = s.slice(6, 14);
-		const sequence = parseInt(s.slice(14, 17), 10);
-		const checksum = s.slice(17, 18);
-		const valid = Checksum.validate(s);
-		const sex = sequence % 2 === 1 ? 'Male' : 'Female';
-		return {
-			division,
-			birthDate,
-			sequence,
-			checksum,
-			valid,
-			sex,
-			male: sex === 'Male',
-			female: sex === 'Female',
-			age: new Date().getFullYear() - parseInt(birthDate.slice(0, 4), 10),
-		};
-	}
-
-	export function format({
-		division,
-		birthDate,
-		sequence,
-		checksum,
-	}: {
-		division: string;
-		birthDate: string | Date;
-		sequence: number | string;
-		checksum?: string;
-	}) {
-		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');
-		const base = [division, birthDate, sequence].join('');
-		if (base.length !== 17) throw new Error('Invalid params');
-		checksum ||= Checksum.compute(base);
-		return base + checksum;
-	}
-}
-export interface ParsedResidentIdentityCardNumber {
-	/**
-	 * @title 行政区划代码
-	 */
-	division: string;
-	/**
-	 * @title 出生日期
-	 * 格式 yyyyMMDD
-	 */
-	birthDate: string;
-	/**
-	 * @title 顺序码
-	 */
-	sequence: number;
-	/**
-	 * @title 校验位
-	 */
-	checksum: string;
-
-	/**
-	 * @title 是否有效
-	 */
-	valid: boolean;
-	/**
-	 * @title 是否男性
-	 */
-	male: boolean;
-	/**
-	 * @title 是否女性
-	 */
-	female: boolean;
-	/**
-	 * @title 性别
-	 */
-	sex: 'Male' | 'Female';
-	/**
-	 * @title 年龄
-	 */
-	age: number;
-}

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

@@ -1,15 +0,0 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
-
-exports[`ResidentIdentityCardNumber > should parse 1`] = `
-{
-  "age": 76,
-  "birthDate": "19491231",
-  "checksum": "X",
-  "division": "110105",
-  "female": true,
-  "male": false,
-  "sequence": 2,
-  "sex": "Female",
-  "valid": true,
-}
-`;

package/src/cn/formatDate.ts

@@ -1,12 +0,0 @@
-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`);
-	}
-}

package/src/cn/parseSex.ts

@@ -1,13 +0,0 @@
-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;
-}

package/src/resource/schema/SchemaRegistry.ts

@@ -1,42 +0,0 @@
-import { getGlobalStates } from '@wener/utils';
-import type { JsonSchemaDef } from '../../jsonschema';
-import { toJsonSchema, type SchemaOutput, type TypeSchema } from '../../schema';
-
-const types = getGlobalStates('@wener/common/resource/schema/SchemaRegistry', () => new Map<string, JsonSchemaDef>());
-
-export function get(name: string): JsonSchemaDef;
-export function get<S extends TypeSchema>(schema: S): JsonSchemaDef<SchemaOutput<S>>;
-export function get(needle: TypeSchema | string) {
-	let key = getKey(needle);
-	let found = types.get(key);
-	if (found) {
-		return found;
-	} else {
-		if (typeof needle !== 'string') {
-			return toJsonSchema(needle);
-		}
-	}
-	throw new Error(`Schema not found: ${key}`);
-}
-
-function getKey(s: TypeSchema | string) {
-	let key;
-	if (typeof s === 'string') {
-		key = s;
-	} else {
-		let js = toJsonSchema(s);
-		key = js.$id || js.title;
-	}
-	if (!key) {
-		throw new Error(`Schema must have $id or title`);
-	}
-	return key;
-}
-
-export function add(def: TypeSchema) {
-	types.set(getKey(def), toJsonSchema(def));
-}
-
-export function set(key: TypeSchema | string, def: TypeSchema) {
-	types.set(getKey(key), toJsonSchema(def));
-}

package/src/resource/schema/SexType.ts

@@ -1,13 +0,0 @@
-import { z } from 'zod/v4';
-import type { EnumValues } from './types';
-
-export const SexType = Object.freeze({
-	__proto__: null,
-	Male: 'Male',
-	Female: 'Female',
-	// Intersex
-} as const);
-export type SexType = EnumValues<typeof SexType>;
-export const SexTypeSchema = z
-	.union([z.literal(SexType.Male).describe('男'), z.literal(SexType.Female).describe('女')])
-	.describe('性别');

package/src/search/AdvanceSearch.test.ts

@@ -1,149 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { AdvanceSearch } from './AdvanceSearch';
-
-describe('AdvanceSearch', () => {
-	it('should parse', () => {
-		for (const input of [
-			//
-			'-a',
-			'a',
-			'a b',
-			'a -b',
-			'a-b',
-			'a"b',
-			'a&b',
-			'NOT a',
-			'NOT -a',
-			'HELLO -WORLD',
-			'(a)',
-			'( a OR B )',
-			'A OR B',
-			'a:[1,2]',
-			'a:*..1',
-			'a:ok a:=1 a:>1 a:<1 a:>=1 a:<=1 a:!=1 a:1..2 a:*..1 a:1..* a:[1,2] a:(1,2) a:[1,2) a:(1,2]',
-			'NOT (A B) AND (a:ok AND size:>1)',
-			'NOT -a',
-			'NOT (NOT -a)',
-			'owner:@me owner:=@me owner:!=@me',
-			'@AI:"Where is my car"',
-			'/**/ a',
-			'/* Hint */ a',
-			'/* a */ a /* b */',
-		]) {
-			let out = AdvanceSearch.parse(input);
-			let formated = AdvanceSearch.format(out);
-			expect(formated, `reformat`).toMatchSnapshot();
-			let optimized = AdvanceSearch.format(AdvanceSearch.optimize(out));
-			expect(optimized, `optimized`).toMatchSnapshot();
-			expect(out, `parsed`).toMatchSnapshot();
-			expect(AdvanceSearch.parse(formated), `reformat match original`).toMatchObject(out);
-		}
-	});
-	it('should parse as expected', () => {
-		type Case = [string | null | undefined, AdvanceSearch.Expr[]];
-
-		const cases: Case[] = [
-			[null, []],
-			[undefined, []],
-			['', []],
-			// fast path
-			['a', [{ type: 'keyword', value: 'a' }]],
-			['a-b', [{ type: 'keyword', value: 'a-b' }]],
-			['a"b', [{ type: 'keyword', value: 'a"b' }]],
-			[
-				'hello world',
-				[
-					{ type: 'keyword', value: 'hello' },
-					{ type: 'keyword', value: 'world' },
-				],
-			],
-			// advance
-			['-a', [{ type: 'keyword', value: 'a', negative: true }]],
-			[
-				'/*Hi*/ hello -world',
-				[
-					{ type: 'comment', value: 'Hi' },
-					{ type: 'keyword', value: 'hello', negative: false },
-					{ type: 'keyword', value: 'world', negative: true },
-				],
-			],
-			['"Hello"', [{ type: 'keyword', value: 'Hello', exact: true }]],
-			['-"Hello"', [{ type: 'keyword', value: 'Hello', exact: true, negative: true }]],
-			['is:ok', [{ type: 'compare', field: 'is', operator: 'match', value: { value: 'ok' } }]],
-			['-is:ok', [{ type: 'compare', field: 'is', negative: true, operator: 'match', value: { value: 'ok' } }]],
-		];
-
-		for (const [input, expected] of cases) {
-			let out = AdvanceSearch.parse(input);
-			expect(out).toMatchObject(expected);
-			expect(AdvanceSearch.parse(AdvanceSearch.format(out)), 'reformat should match').toMatchObject(expected);
-		}
-	});
-
-	it('should optimize simple', () => {
-		type Case = { input: AdvanceSearch.Expr[]; expected: AdvanceSearch.Expr[] };
-		const cases: Case[] = [
-			// rm empty comment
-			{
-				input: [
-					{ type: 'comment', value: '' },
-					{ type: 'keyword', value: 'a' },
-				],
-				expected: [{ type: 'keyword', value: 'a' }],
-			},
-			// unwrap parentheses
-			{
-				input: [
-					{ type: 'parentheses', value: [{ type: 'keyword', value: 'a' }] },
-					{ type: 'keyword', value: 'b' },
-				],
-				expected: [
-					{ type: 'keyword', value: 'a' },
-					{ type: 'keyword', value: 'b' },
-				],
-			},
-			// not not
-			{
-				input: [{ type: 'not', value: { type: 'not', value: { type: 'keyword', value: 'a' } } }],
-				expected: [{ type: 'keyword', value: 'a', negative: false }],
-			},
-			// not to negative
-			{
-				input: [{ type: 'not', value: { type: 'keyword', value: 'a' } }],
-				expected: [{ type: 'keyword', value: 'a', negative: true }],
-			},
-		];
-
-		for (let i = 0; i < cases.length; i++) {
-			const { input, expected } = cases[i];
-			let out = AdvanceSearch.optimize(input);
-			expect(out, `case #${i}`).toEqual(expected);
-		}
-	});
-
-	it('should optimize by formated', () => {
-		type Case = [string, string];
-
-		const cases: Case[] = [
-			['( a )', 'a'],
-			['NOT a', '-a'],
-			['NOT -a', 'a'],
-			['NOT is:ok', '-is:ok'],
-			['NOT -is:ok', 'is:ok'],
-			['NOT -is:=ok', 'is:=ok'],
-			['NOT is:=ok', 'is:!=ok'],
-			['NOT (NOT -a)', '-a'],
-		];
-
-		for (const [input, expected] of cases) {
-			let out = AdvanceSearch.optimize(AdvanceSearch.parse(input));
-			expect(AdvanceSearch.format(out), `${input} -> ${expected}: ${JSON.stringify(out)}`).toEqual(expected);
-		}
-	});
-
-	it.fails('should parse parentheses', () => {
-		let out = AdvanceSearch.parse('(a)');
-		console.log(out);
-		expect(out).toEqual([{ type: 'parentheses', value: [{ type: 'keyword', value: 'a' }] }]);
-	});
-});

package/src/search/AdvanceSearch.ts

@@ -1,14 +0,0 @@
-import { formatAdvanceSearch } from './formatAdvanceSearch';
-import { optimizeAdvanceSearch } from './optimizeAdvanceSearch';
-import { parseAdvanceSearch } from './parseAdvanceSearch';
-import type * as types from './types';
-
-export namespace AdvanceSearch {
-	export type Exprs = types.Exprs;
-	export type Expr = types.Expr;
-	export type Value = types.Value;
-
-	export const parse = parseAdvanceSearch;
-	export const format = formatAdvanceSearch;
-	export const optimize = optimizeAdvanceSearch;
-}

package/src/search/Makefile

@@ -1,2 +0,0 @@
-gen:
-	pnpm dlx peggy@latest $(PWD)/parser.peggy --format es