@wener/utils 1.1.39 → 1.1.41

package/src/cn/id/ResidentIdNumber.ts

@@ -33,40 +33,62 @@ export class ResidentIdNumber {
     let d = parseInt(date.slice(6));
     return new IdNumber(
       s.slice(0, 6),
-      new Date(`${y}-${m}-${d}`), // YYYYMMDD
-      // new Date(y, m - 1, d, 0, 0, 0, 0), // 有时区问题
+      // new Date(`${y}-${m}-${d}`), // YYYYMMDD
+      new Date(Date.UTC(y, m - 1, d)), // 避免时区问题
       parseInt(s.slice(14, 17)),
       s.slice(17, 18).toUpperCase(),
     );
   }
 }
 
+interface ParseResidentIdNumberResult {
+  division: string;
+  birthDate: Date;
+  sequence: number;
+  checksum: string;
+
+  valid: boolean;
+  male: boolean;
+  female: boolean;
+  sex: 'Male' | 'Female';
+  age: number;
+}
+
 class IdNumber {
   constructor(
     public division: string,
-    public date: Date,
+    public birthDate: Date,
     public sequence: number,
     public checksum: string,
   ) {}
 
   toString() {
-    return this.subject + this.checksum;
+    return this.base + this.checksum;
   }
 
   toJSON() {
     return this.toString();
   }
 
-  toObject() {
-    const { division, date, sequence, checksum } = this;
+  toObject(): ParseResidentIdNumberResult {
+    const { division, birthDate, sequence, checksum, age, valid, male, female, sex } = this;
     return {
       division,
-      date,
+      birthDate,
       sequence,
       checksum,
+      age,
+      valid,
+      male,
+      female,
+      sex,
     };
   }
 
+  get valid() {
+    return ResidentIdNumber.get().verify(this.toString());
+  }
+
   get male() {
     return this.sequence % 2 === 1;
   }
@@ -76,15 +98,19 @@ class IdNumber {
   }
 
   get age() {
-    return new Date().getFullYear() - this.date.getFullYear();
+    return new Date().getFullYear() - this.birthDate.getFullYear();
   }
 
-  get gender(): 'male' | 'female' {
-    return this.sequence % 2 === 1 ? 'male' : 'female';
+  get sex(): 'Male' | 'Female' {
+    return this.sequence % 2 === 1 ? 'Male' : 'Female';
   }
 
-  get subject() {
-    return [this.division, formatDate(this.date, 'YYYYMMDD'), this.sequence.toString().padStart(3, '0')].join('');
+  /**
+   * base for checksum
+   * @private
+   */
+  private get base() {
+    return [this.division, formatDate(this.birthDate, 'YYYYMMDD'), this.sequence.toString().padStart(3, '0')].join('');
   }
 }
 

package/src/cn/id/id.test.ts

@@ -1,4 +1,4 @@
-import { test, assert, expect } from 'vitest';
+import { assert, expect, test } from 'vitest';
 import { Mod11Checksum } from './Mod11Checksum';
 import { ResidentIdNumber } from './ResidentIdNumber';
 

package/src/cn/index.ts

@@ -12,3 +12,5 @@ export { USCC } from './uscc/USCC';
 export { ResidentIdNumber } from './id/ResidentIdNumber';
 
 export { DivisionCode } from './division/DivisionCode';
+
+export { toPinyinPure, toPinyinPureFirst, getCharToPinyinTable, loadCharToPinyinTable } from './pinyin/toPinyinPure';

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

@@ -0,0 +1,64 @@
+import { describe, expect, test } from 'vitest';
+import { cartesianProduct } from './cartesianProduct';
+
+describe('cartesianProduct', () => {
+  test('combines two arrays with multiple elements', () => {
+    expect(
+      cartesianProduct([
+        [1, 2],
+        [3, 4],
+      ]),
+    ).toEqual([
+      [1, 3],
+      [1, 4],
+      [2, 3],
+      [2, 4],
+    ]);
+  });
+
+  test('combines multiple arrays', () => {
+    expect(cartesianProduct([[1, 2], [3], [4, 5]])).toEqual([
+      [1, 3, 4],
+      [1, 3, 5],
+      [2, 3, 4],
+      [2, 3, 5],
+    ]);
+  });
+
+  test('handles an empty array input correctly', () => {
+    expect(cartesianProduct([])).toEqual([]);
+  });
+
+  test('handles one array being empty', () => {
+    expect(cartesianProduct([[1, 2], [], [3]])).toEqual([]);
+  });
+
+  test('works with arrays of different types', () => {
+    expect(
+      cartesianProduct<string | number>([
+        ['a', 'b'],
+        [1, 2],
+      ]),
+    ).toEqual([
+      ['a', 1],
+      ['a', 2],
+      ['b', 1],
+      ['b', 2],
+    ]);
+  });
+
+  test('handles single-element arrays', () => {
+    expect(cartesianProduct([[1], [2], [3]])).toEqual([[1, 2, 3]]);
+  });
+
+  test('works with more complex objects', () => {
+    expect(cartesianProduct<any>([[{ id: 1 }, { id: 2 }], ['a']])).toEqual([
+      [{ id: 1 }, 'a'],
+      [{ id: 2 }, 'a'],
+    ]);
+  });
+
+  test('handles an array containing a single array', () => {
+    expect(cartesianProduct([[1, 2, 3]])).toEqual([[1], [2], [3]]);
+  });
+});

package/src/cn/pinyin/cartesianProduct.ts

@@ -0,0 +1,24 @@
+export function cartesianProduct<T>(args: T[][]): T[][] {
+  if (args.length === 0) return [];
+
+  const product: T[][] = [];
+  const counts = args.map((arr) => arr.length);
+  const counter = new Array(args.length).fill(0);
+  const total = counts.reduce((acc, val) => acc * val, 1);
+
+  for (let i = 0; i < total; i++) {
+    product.push(counter.map((count, index) => args[index][count]));
+
+    // Update the counter for the next row in the Cartesian product.
+    for (let j = args.length - 1; j >= 0; j--) {
+      if (counter[j] + 1 < counts[j]) {
+        counter[j]++;
+        break; // Stop as we've found a digit that can be incremented.
+      } else {
+        counter[j] = 0; // Reset this digit and increment the next digit in the next iteration.
+      }
+    }
+  }
+
+  return product;
+}