@wener/utils 1.1.36 → 1.1.38

package/src/cn/id/ResidentIdNumber.ts

@@ -0,0 +1,102 @@
+import { Mod11Checksum } from './Mod11Checksum';
+
+export class ResidentIdNumber {
+  checksum = Mod11Checksum.get();
+
+  // 9 https://zh.wikipedia.org/wiki/中华人民共和国外国人永久居留身份证
+  // 9 标识码
+  // 申领地代码 - 2 位行政区划
+  // 国籍国代码 - 3 位数字 https://zh.wikipedia.org/wiki/ISO_3166-1数字代码
+
+  regex =
+    /^(?<division>[1-9]\d{5})(?<year>18|19|20)\d{2}(?<month>0[1-9]|1[0-2])(?<day>0[1-9]|[12]\d|3[01])(?<sequence>\d{3})(?<checksum>[0-9Xx])$/;
+
+  private static instance: ResidentIdNumber;
+
+  static get() {
+    return (this.instance ||= new ResidentIdNumber());
+  }
+
+  verify(s: string) {
+    if (!s) return false;
+    return this.regex.test(s) && this.checksum.verify(s.toUpperCase());
+  }
+
+  parse(s: string): IdNumber | undefined {
+    if (!this.verify(s)) {
+      return;
+    }
+
+    let date = s.slice(6, 14);
+    let y = parseInt(date.slice(0, 4));
+    let m = parseInt(date.slice(4, 6));
+    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), // 有时区问题
+      parseInt(s.slice(14, 17)),
+      s.slice(17, 18).toUpperCase(),
+    );
+  }
+}
+
+class IdNumber {
+  constructor(
+    public division: string,
+    public date: Date,
+    public sequence: number,
+    public checksum: string,
+  ) {}
+
+  toString() {
+    return this.subject + this.checksum;
+  }
+
+  toJSON() {
+    return this.toString();
+  }
+
+  toObject() {
+    const { division, date, sequence, checksum } = this;
+    return {
+      division,
+      date,
+      sequence,
+      checksum,
+    };
+  }
+
+  get male() {
+    return this.sequence % 2 === 1;
+  }
+
+  get female() {
+    return this.sequence % 2 === 0;
+  }
+
+  get age() {
+    return new Date().getFullYear() - this.date.getFullYear();
+  }
+
+  get gender(): '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('');
+  }
+}
+
+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/id/id.test.ts

@@ -0,0 +1,20 @@
+import { test, assert, expect } from 'vitest';
+import { Mod11Checksum } from './Mod11Checksum';
+import { ResidentIdNumber } from './ResidentIdNumber';
+
+test('id', (t) => {
+  const ids = ['11010519491231002X', '11010219840406970X'];
+
+  let cs = Mod11Checksum.get();
+  for (const id of ids) {
+    assert.equal(cs.generate(id.slice(0, -1)), id.at(-1));
+  }
+
+  let parse = ResidentIdNumber.get().parse(ids[0]);
+  expect(parse?.toObject()).toEqual({
+    division: '110105',
+    date: new Date('1949-12-31'),
+    sequence: 2,
+    checksum: 'X',
+  });
+});

package/src/cn/id/types.ts

@@ -0,0 +1,26 @@
+/**
+ * 居民身份证
+ *
+ * @see https://en.wikipedia.org/wiki/Resident_Identity_Card
+ * @see https://en.wikipedia.org/wiki/Foreign_Permanent_Resident_ID_Card
+ */
+export interface ResidentIdentityCard {
+  // 姓名
+  name: string;
+  // 性别
+  gender: string;
+  // 民族
+  ethnicity: string;
+  // 出生日期
+  birthDate: Date;
+  // 地址
+  domicile: string;
+  // 身份证号
+  idNumber: string;
+  // 签发机关
+  issuingAuthority: string;
+  // 有效期开始日期
+  validStartDate: Date;
+  // 有效期结束日期
+  validEndDate?: Date;
+}

package/src/cn/index.ts

@@ -1 +1,14 @@
+/**
+ * China related utilities.
+ *
+ * @packageDocumentation
+ */
+
 export { parseChineseNumber } from './parseChineseNumber';
+
+export { isUSCC } from './uscc/isUSCC';
+export { USCC } from './uscc/USCC';
+
+export { ResidentIdNumber } from './id/ResidentIdNumber';
+
+export { DivisionCode } from './division/DivisionCode';

package/src/cn/uscc/Mod31Checksum.ts

@@ -0,0 +1,42 @@
+/**
+ * GB/T 17710（采ISO 7064）的模31校验码
+ *
+ * Mod31-3
+ */
+export class Mod31Checksum {
+  weights = [1, 3, 9, 27, 19, 26, 16, 17, 20, 29, 25, 13, 8, 24, 10, 30, 28];
+  chars = '0123456789ABCDEFGHJKLMNPQRTUWXY';
+  numbers: Record<string, number> = this.chars.split('').reduce(
+    (acc, cur, i) => {
+      acc[cur] = i;
+      return acc;
+    },
+    {} as Record<string, number>,
+  );
+
+  private static instance: Mod31Checksum;
+
+  static get() {
+    return this.instance || (this.instance = new Mod31Checksum());
+  }
+
+  toChar(n: number) {
+    return this.chars[n];
+  }
+
+  toNumber(c: string) {
+    return this.numbers[c];
+  }
+
+  verify(s: string) {
+    return s.at(-1) === this.generate(s.slice(0, s.length - 1));
+  }
+
+  generate(s: string) {
+    let sum = 0;
+    for (let i = 0; i < s.length; i++) {
+      sum += this.numbers[s[i]] * this.weights[i];
+    }
+    return this.toChar(31 - (sum % 31));
+  }
+}

package/src/cn/uscc/USCC.ts

@@ -0,0 +1,98 @@
+import { Mod31Checksum } from './Mod31Checksum';
+
+/**
+ * - GB 32100-2015 法人和其他组织统一社会信用代码编码规则
+ * - USCI -> UnifiedSocialCreditIdentifier
+ * - USCC -> Unified Social Credit Code - 官方叫法
+ * - Business License
+ *
+ * @see https://en.wikipedia.org/wiki/Unified_Social_Credit_Identifier
+ */
+export class USCC {
+  registryCodeLabels: Record<string, Code> = {
+    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: '其他' },
+      },
+    },
+  };
+
+  /* 16 位 */
+  regex = /^([159][1239]|Y1)[0-9]{6}[0-9A-HJ-NP-RTUWXY]{10}$/; // 无 I O Z S V
+  checksum = Mod31Checksum.get();
+
+  static instance: USCC;
+
+  static get() {
+    return (this.instance ||= new USCC());
+  }
+
+  parse(s: string): ParsedUSCC {
+    let registryCode = s[0];
+    let l1 = this.registryCodeLabels[registryCode];
+    let organizationTypeCode = s[1];
+    return {
+      registryAuthorityCode: registryCode,
+      registryAuthorityCodeLabel: l1?.label,
+      organizationTypeCode,
+      organizationTypeLabel: l1?.children?.[organizationTypeCode]?.label,
+      registryDivisionCode: s.slice(3, 6),
+      // GB 11714-1997 全国组织机构代码编制规则
+      subject: s.slice(6, 15),
+      checksum: s.slice(17, 18),
+    };
+  }
+
+  verify(s: string) {
+    return this.regex.test(s) && this.checksum.verify(s);
+  }
+}
+
+interface Code {
+  label: string;
+  children?: Record<string, Code>;
+}
+
+interface ParsedUSCC {
+  // 登记管理部门码
+  registryAuthorityCode: string;
+  registryAuthorityCodeLabel?: string;
+  // 机构类别代码
+  organizationTypeCode: string;
+  organizationTypeLabel?: string;
+  // 登记管理机关行政区划代码
+  registryDivisionCode: string;
+  registryDivisionLabel?: string;
+  // 主体标识码
+  subject: string;
+  // 校验码
+  checksum: string;
+}

package/src/cn/uscc/isUSCC.ts

@@ -0,0 +1,8 @@
+import { USCC } from './USCC';
+
+/**
+ * USCC - 统一社会信用代码
+ */
+export function isUSCC(s: string) {
+  return USCC.get().verify(s);
+}

package/src/cn/uscc/uscc.test.ts

@@ -0,0 +1,16 @@
+import { test, expect } from 'vitest';
+import { Mod31Checksum } from './Mod31Checksum';
+import { USCC } from './USCC';
+import { isUSCC } from './isUSCC';
+
+test('uscc', () => {
+  let cs = Mod31Checksum.get();
+
+  // 阿里云计算
+  expect(cs.verify('91330106673959654P')).toBeTruthy();
+  expect(cs.generate('91330106673959654')).toBe('P');
+
+  expect(isUSCC('91330106673959654P')).toBeTruthy();
+
+  console.log(USCC.get().parse('91330106673959654P'));
+});

package/src/crypto/getRandomValues.ts

@@ -1,6 +1,6 @@
 // eslint-disable-next-line @typescript-eslint/consistent-type-imports
 import type { TypedArray } from '../io/ArrayBuffers';
-import { getGlobalThis } from '../isomorphics/getGlobalThis';
+import { getGlobalThis } from '../runtime/getGlobalThis';
 import { getNodeCrypto } from './getNodeCrypto';
 
 const globalThis = getGlobalThis();

package/src/crypto/randomUUID.ts

@@ -1,4 +1,4 @@
-import { getGlobalThis } from '../isomorphics/getGlobalThis';
+import { getGlobalThis } from '../runtime/getGlobalThis';
 
 const globalThis = getGlobalThis();
 

package/src/crypto/randomUUIDv7.ts

@@ -0,0 +1 @@
+// https://github.com/LiosK/uuidv7/blob/main/src/index.ts

package/src/errors/Errors.ts

@@ -1,4 +1,4 @@
-import { getHttpStatusText } from '../http/HttpStatus';
+import { getHttpStatusText } from '../fetch/HttpStatus';
 
 export interface ErrorDetailInit {
   message?: string;

package/src/fetch/createFetchWith.ts

@@ -1,5 +1,5 @@
 import { MaybePromise } from '../asyncs/MaybePromise';
-import { getGlobalThis } from '../isomorphics/getGlobalThis';
+import { getGlobalThis } from '../runtime/getGlobalThis';
 import { type FetchLike } from './types';
 
 export function createFetchWith({

package/src/fetch/createFetchWithRetry.ts

@@ -1,4 +1,4 @@
-import { getGlobalThis } from '../isomorphics/getGlobalThis';
+import { getGlobalThis } from '../runtime/getGlobalThis';
 import { FetchLike } from './types';
 
 type RequestDelayFunction = (attempt: number, error: Error | null, response: Response | null) => number;

package/src/index.ts

@@ -12,6 +12,7 @@ export { arrayFromAsync } from './arrays/arrayFromAsync';
 export { get } from './objects/get';
 export { set } from './objects/set';
 export { parseObjectPath } from './objects/parseObjectPath';
+export { computeIfAbsent } from './objects/computeIfAbsent';
 export { merge, type MergeOptions } from './objects/merge';
 
 // async
@@ -42,8 +43,8 @@ export { isPlainObject } from './langs/isPlainObject';
 export { parseBoolean } from './langs/parseBoolean';
 export { maybeFunction, type MaybeFunction } from './langs/MaybeFunction';
 export { memoize } from './langs/memoize';
-export { AsyncCloser } from './langs/AsyncCloser';
-export { Closer } from './langs/Closer';
+export { AsyncCloser } from './runtime/AsyncCloser';
+export { Closer } from './runtime/Closer';
 
 export { isUUID } from './validations/isUUID';
 export { parseTimestamp } from './validations/parseTimestamp';
@@ -71,6 +72,7 @@ export { isBuffer } from './io/isBuffer';
 export { isTransferable } from './io/isTransferable';
 export { ArrayBuffers } from './io/ArrayBuffers';
 export { Buffer } from './io/Buffer';
+export { parseDataUri, type ParsedDataUri } from './io/parseDataUri';
 export type { AbstractEncoding } from './io/AbstractEncoding';
 
 // browser
@@ -80,8 +82,8 @@ export { loadScripts, loadStyles } from './browsers/loaders';
 export { getFileFromDataTransfer } from './browsers/getFileFromDataTransfer';
 
 // polyfills
-export { getGlobalThis } from './isomorphics/getGlobalThis';
-export { structuredClone } from './isomorphics/structuredClone';
+export { getGlobalThis } from './runtime/getGlobalThis';
+export { structuredClone } from './runtime/structuredClone';
 
 // crypto
 export { randomUUID } from './crypto/randomUUID';
@@ -113,6 +115,6 @@ export { default as ms } from './libs/ms';
 // error
 export { Errors, DetailError, type ErrorDetail, type ErrorDetailInit } from './errors/Errors';
 // http
-export { getHttpStatusText, isRetryableHttpStatus } from './http/HttpStatus';
+export { getHttpStatusText, isRetryableHttpStatus } from './fetch/HttpStatus';
 
 export type * from './types';

package/src/io/ArrayBuffers.base64.test.ts

@@ -60,3 +60,27 @@ test('base64: high byte', function () {
   const highByte = ArrayBuffers.from([128]);
   assert.deepEqual(ArrayBuffers.alloc(1, ArrayBuffers.toString(highByte, 'base64'), 'base64'), highByte);
 });
+
+test('fromBase64', () => {
+  const text = 'aoeu';
+  const buf = ArrayBuffers.from(text, 'utf8', Uint8Array);
+  expect(ArrayBuffers.fromBase64(ArrayBuffers.toBase64(buf))).toEqual(buf);
+});
+
+test('fromHex', () => {
+  const text = 'aoeu';
+  const buf = ArrayBuffers.from(text, 'utf8', Uint8Array);
+  expect(ArrayBuffers.fromHex(ArrayBuffers.toHex(buf))).toEqual(buf);
+});
+
+test('toHex', () => {
+  const text = 'aoeu';
+  const buf = ArrayBuffers.from(text, 'utf8', Uint8Array);
+  expect(ArrayBuffers.toHex(buf)).toEqual('616f6575');
+});
+
+test('toBase64', () => {
+  const text = 'aoeu';
+  const buf = ArrayBuffers.from(text, 'utf8', Uint8Array);
+  expect(ArrayBuffers.toBase64(buf)).toEqual('YW9ldQ==');
+});

package/src/io/ArrayBuffers.ts

@@ -1,10 +1,13 @@
-import { getGlobalThis } from '../isomorphics/getGlobalThis';
 import { classOf } from '../langs/classOf';
+import { getGlobalThis } from '../runtime/getGlobalThis';
 import { decodeBase64ToArrayBuffer, encodeArrayBufferToBase64 } from './base64';
 import { isBuffer } from './isBuffer';
 
 /**
  * Various utils to work with {@link ArrayBuffer}
+ *
+ * @see https://github.com/tc39/proposal-arraybuffer-base64
+ * @see https://github.com/tc39/proposal-resizablearraybuffer
  */
 export interface ArrayBuffers {
   /**
@@ -48,10 +51,26 @@ export interface ArrayBuffers {
    */
   from(v: string | BufferSource, encoding?: ToStringEncoding): ArrayBuffer;
 
+  from<C extends ArrayBufferViewConstructor<unknown>>(
+    v: string | BufferSource,
+    encoding: ToStringEncoding,
+    TypedArray: C,
+  ): C;
+
   /**
    * concat the given {@link BufferSource} to a new {@link ArrayBuffer}
    */
   concat(buffers: Array<BufferSource>, result?: ArrayBuffer, offset?: number): ArrayBuffer;
+
+  fromBase64(v: string): Uint8Array;
+
+  fromHex(v: string): Uint8Array;
+
+  toBase64(v: BufferSource): string;
+
+  toHex(v: BufferSource): string;
+
+  resize(v: ArrayBuffer, newByteLength: number): ArrayBuffer;
 }
 
 type ToStringEncoding =
@@ -89,6 +108,67 @@ export class ArrayBuffers {
     return v instanceof ArrayBuffer;
   };
 
+  static toArrayBuffer(v: BufferSource): ArrayBuffer {
+    return v instanceof ArrayBuffer ? v : (v.buffer as ArrayBuffer);
+  }
+
+  static toUint8Array(v: BufferSource) {
+    return ArrayBuffers.asView(Uint8Array, v);
+  }
+
+  static toBase64 = (v: BufferSource) => {
+    if ('toBase64' in Uint8Array.prototype) {
+      return this.toUint8Array(v).toBase64();
+    }
+
+    if (ArrayBuffers.isNativeBufferAllowed()) {
+      return Buffer.from(ArrayBuffers.asView(Uint8Array, v)).toString('base64');
+    }
+
+    return encodeArrayBufferToBase64(this.toArrayBuffer(v));
+  };
+
+  static toHex = (v: BufferSource) => {
+    if ('toHex' in Uint8Array.prototype) {
+      return this.toUint8Array(v).toHex();
+    }
+    if (ArrayBuffers.isNativeBufferAllowed()) {
+      return Buffer.from(ArrayBuffers.asView(Uint8Array, v)).toString('hex');
+    }
+    return ArrayBuffers.toString(v, 'hex');
+  };
+
+  static fromBase64 = (v: string) => {
+    if ('fromBase64' in Uint8Array) {
+      return Uint8Array.fromBase64(v);
+    }
+    if (ArrayBuffers.isNativeBufferAllowed()) {
+      return Buffer.from(v, 'base64');
+    }
+    return this.toUint8Array(decodeBase64ToArrayBuffer(v));
+  };
+
+  static fromHex = (v: string) => {
+    if ('fromHex' in Uint8Array) {
+      return Uint8Array.fromHex(v);
+    }
+    return this.toUint8Array(ArrayBuffers.from(v, 'hex'));
+  };
+
+  static resize = (v: ArrayBuffer, newByteLength: number): ArrayBuffer => {
+    if ('resize' in v) {
+      (v as any).resize(newByteLength);
+      return v;
+    }
+
+    const old = v;
+    const newBuf = new ArrayBuffer(newByteLength);
+    const oldView = new Uint8Array(old);
+    const newView = new Uint8Array(newBuf);
+    newView.set(oldView);
+    return newBuf;
+  };
+
   static slice = (o: TypedArray, start?: number, end?: number) => {
     // NodeJS Buffer slice is not the same as UInt8Array slice
     // https://nodejs.org/api/buffer.html#bufslicestart-end
@@ -195,7 +275,11 @@ export class ArrayBuffers {
   static from = (
     v: string | BufferSource | ArrayLike<number> | Iterable<number>,
     encoding: ToStringEncoding = 'utf8',
-  ): BufferSource => {
+    view?: any,
+  ): any => {
+    if (view) {
+      return this.asView(view, this.from(v, encoding));
+    }
     if (!v) {
       return new ArrayBuffer(0);
     }
@@ -212,8 +296,8 @@ export class ArrayBuffers {
         case 'base64':
           // replaceAll need higher version of nodejs
           return decodeBase64ToArrayBuffer(v.replace(/[^0-9a-zA-Z=+/_]/g, ''));
-        // error in nodejs 18
-        // return Uint8Array.from(atob(v.replace(/[^0-9a-zA-Z=+/_ \r\n]/g, '')), (c) => c.charCodeAt(0));
+        case 'hex':
+          return new Uint8Array(v.match(/.{1,2}/g)!.map((byte) => parseInt(byte, 16))).buffer;
         default:
           throw new Error(`[ArrayBuffers.from] Unknown encoding: ${encoding}`);
       }
@@ -303,3 +387,21 @@ const hexLookupTable = (function () {
   }
   return table;
 })();
+
+declare global {
+  interface ArrayBuffer {
+    // resize(newByteLength: number): void;
+  }
+
+  interface Uint8Array {
+    toBase64(): string;
+
+    toHex(): string;
+  }
+
+  interface Uint8ArrayConstructor {
+    fromBase64(v: string): Uint8Array;
+
+    fromHex(v: string): Uint8Array;
+  }
+}

package/src/io/isTransferable.ts

@@ -1,4 +1,4 @@
-import { getGlobalThis } from '../isomorphics/getGlobalThis';
+import { getGlobalThis } from '../runtime/getGlobalThis';
 
 const globalThis = getGlobalThis();
 

package/src/io/parseDataUri.test.ts

@@ -0,0 +1,34 @@
+import { assert, test } from 'vitest';
+import { ArrayBuffers } from './ArrayBuffers';
+import { parseDataUri } from './parseDataUri';
+
+test('parseDataUri', async () => {
+  {
+    let uri = 'data:text/plain;base64,SGVsbG8sIFdvcmxkIQ==';
+    const { getData, ...out } = parseDataUri(uri)!;
+    assert.deepEqual(out, {
+      type: 'text/plain',
+      params: { base64: true },
+      content: 'SGVsbG8sIFdvcmxkIQ==',
+      base64: true,
+    });
+    assert.equal(await getData('utf-8'), await fetch(uri).then((v) => v.text()));
+    assert.equal(await getData('base64'), 'SGVsbG8sIFdvcmxkIQ==');
+  }
+  {
+    // text
+    let uri = 'data:text/plain,Hello%2C%20World!';
+    const { getData, ...out } = parseDataUri(uri)!;
+    assert.deepEqual(out, {
+      type: 'text/plain',
+      params: {},
+      content: 'Hello%2C%20World!',
+      base64: false,
+    });
+
+    assert.equal(await getData('utf-8'), 'Hello, World!');
+    assert.deepEqual(ArrayBuffers.asView(Uint8Array, await getData()), new TextEncoder().encode('Hello, World!'));
+    assert.equal(await getData('utf-8'), await fetch(uri).then((v) => v.text()));
+    assert.equal(await getData('base64'), 'SGVsbG8sIFdvcmxkIQ==');
+  }
+});