stdnum 1.10.0 → 1.10.2

package/src/mx/clabe.spec.ts

@@ -0,0 +1,68 @@
+import { validate } from './clabe';
+import {
+  InvalidLength,
+  InvalidComponent,
+  InvalidChecksum,
+} from '../exceptions';
+
+describe('mx/clabe', () => {
+  it('validate:12345678901234567', () => {
+    const result = validate('12345678901234567');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:000000000000000000', () => {
+    const result = validate('000000000000000000');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:002115016003269411', () => {
+    const result = validate('002115016003269411');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:00000000000000000a', () => {
+    const result = validate('00000000000000000a');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:002010077777777779', () => {
+    const result = validate('002010077777777779');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:002010077777777771', () => {
+    const result = validate('002010077777777771');
+
+    expect(result.isValid && result.compact).toEqual('002010077777777771');
+  });
+
+  it('validate:032180000118359719', () => {
+    const result = validate('032180000118359719');
+
+    expect(result.isValid && result.compact).toEqual('032180000118359719');
+  });
+
+  it('validate:014027000005555558', () => {
+    const result = validate('014027000005555558');
+
+    expect(result.isValid && result.compact).toEqual('014027000005555558');
+  });
+
+  it('validate:014028000005555557', () => {
+    const result = validate('014028000005555557');
+
+    expect(result.isValid && result.compact).toEqual('014028000005555557');
+  });
+
+  it('validate:002010777777777770', () => {
+    const result = validate('002010777777777770');
+
+    expect(result.isValid && result.compact).toEqual('002010777777777770');
+  });
+});

package/src/mx/clabe.ts

@@ -0,0 +1,105 @@
+/**
+ *
+ * The CLABE (Clave Bancaria Estandarizada)
+ *
+ * Spanish for "standardized banking cipher" or "standardized bank code") is a banking standard for the numbering of
+ * bank accounts in Mexico. This standard is a requirement for the sending and receiving of domestic inter-bank
+ * electronic funds transfer since June 1, 2004.
+ *
+ * Sources:
+ *   http://m.sat.gob.mx/contabilidadelectronica/Paginas/documentos/bancos_nacionales.pdf
+ *
+ * BANK
+ */
+
+import * as exceptions from '../exceptions';
+import { strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { banksMap, cities } from './banks';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, '- ');
+}
+
+const impl: Validator = {
+  name: 'Mexican Standardized Bank Code',
+  localName: 'Clave Bancaria Estandarizada',
+  abbreviation: 'CLABE',
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value.toLocaleUpperCase();
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    return value;
+  },
+
+  /**
+   * Check if the number is a valid CLABE.
+   * This checks the length, formatting and other contraints. It does not check
+   * for control letter.
+   */
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 18) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [bankCode, cityCode, account, checksum] = strings.splitAt(
+      value,
+      3,
+      6,
+      17,
+    );
+
+    if (banksMap[parseInt(bankCode, 10)] === undefined) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (cities[parseInt(cityCode, 10)] === undefined) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!strings.isdigits(account)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const sum =
+      (10 -
+        weightedSum(value.substr(0, 17), {
+          weights: [3, 7, 1],
+          modulus: 10,
+        })) %
+      10;
+
+    if (checksum !== String(sum)) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    // const add = (sum, digit, i) => sum + (parseInt(digit, 10) * [3, 7, 1][i % 3]) % 10;
+    // const compute = () => (10 - (clabeNum17.split('').slice(0, 17).reduce(add, 0) % 10)) % 10;
+    // return /^[0-9]{17,18}$/.test(clabeNum17) ? compute() : null;
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/mx/curp.spec.ts

@@ -0,0 +1,28 @@
+import { validate, getBirthDate, getGender } from './curp';
+
+describe('mx/curp', () => {
+  test.each([
+    'BOXW310820HNERXN09',
+    'HELO990501HVZRPN09',
+    'MASI050805MVZRLRA8',
+    'COME721110MVZNRR03',
+    'TEAM470622HVZZPR07',
+    'GARS700923HSPLXL06',
+  ])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid && result.compact).toEqual(value);
+  });
+
+  it('getBirthDate:BOXW310820HNERXN09', () => {
+    const result = getBirthDate('BOXW310820HNERXN09');
+
+    expect(result?.toISOString().substr(0, 10)).toEqual('1931-08-20');
+  });
+
+  it('getGender:BOXW310820HNERXN09', () => {
+    const result = getGender('BOXW310820HNERXN09');
+
+    expect(result).toEqual('M');
+  });
+});

package/src/mx/curp.ts

@@ -0,0 +1,261 @@
+/**
+ * CURP (Clave Única de Registro de Población, Mexican personal ID).
+ *
+ * The Clave Única de Registro de Población (Population Registry Code) is unique
+ * identifier for both citizens and residents of Mexico. The is an 18-character
+ * alphanumeric that contains certain letters from the person's name, their
+ * gender and birth date and a check digit.
+ *
+ * More information:
+ *   https://en.wikipedia.org/wiki/CURP
+ *   https://www.gob.mx/curp/
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import {
+  buildDate,
+  isValidDateCompactYYMMDD,
+  strings,
+  validBirthdate,
+} from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' ');
+}
+
+const nameBlacklist = new Set([
+  'BACA',
+  'BAKA',
+  'BUEI',
+  'BUEY',
+  'CACA',
+  'CACO',
+  'CAGA',
+  'CAGO',
+  'CAKA',
+  'CAKO',
+  'COGE',
+  'COGI',
+  'COJA',
+  'COJE',
+  'COJI',
+  'COJO',
+  'COLA',
+  'CULO',
+  'FALO',
+  'FETO',
+  'GETA',
+  'GUEI',
+  'GUEY',
+  'JETA',
+  'JOTO',
+  'KACA',
+  'KACO',
+  'KAGA',
+  'KAGO',
+  'KAKA',
+  'KAKO',
+  'KOGE',
+  'KOGI',
+  'KOJA',
+  'KOJE',
+  'KOJI',
+  'KOJO',
+  'KOLA',
+  'KULO',
+  'LILO',
+  'LOCA',
+  'LOCO',
+  'LOKA',
+  'LOKO',
+  'MAME',
+  'MAMO',
+  'MEAR',
+  'MEAS',
+  'MEON',
+  'MIAR',
+  'MION',
+  'MOCO',
+  'MOKO',
+  'MULA',
+  'MULO',
+  'NACA',
+  'NACO',
+  'PEDA',
+  'PEDO',
+  'PENE',
+  'PIPI',
+  'PITO',
+  'POPO',
+  'PUTA',
+  'PUTO',
+  'QULO',
+  'RATA',
+  'ROBA',
+  'ROBE',
+  'ROBO',
+  'RUIN',
+  'SENO',
+  'TETA',
+  'VACA',
+  'VAGA',
+  'VAGO',
+  'VAKA',
+  'VUEI',
+  'VUEY',
+  'WUEI',
+  'WUEY',
+]);
+
+const validStates = new Set([
+  'AS',
+  'BC',
+  'BS',
+  'CC',
+  'CH',
+  'CL',
+  'CM',
+  'CS',
+  'DF',
+  'DG',
+  'GR',
+  'GT',
+  'HG',
+  'JC',
+  'MC',
+  'MN',
+  'MS',
+  'NE',
+  'NL',
+  'NT',
+  'OC',
+  'PL',
+  'QR',
+  'QT',
+  'SL',
+  'SP',
+  'SR',
+  'TC',
+  'TL',
+  'TS',
+  'VZ',
+  'YN',
+  'ZS',
+]);
+
+const checkAlphabet = '0123456789ABCDEFGHIJKLMN&OPQRSTUVWXYZ';
+const checkAlphabetDict: Record<string, number> = checkAlphabet
+  .split('')
+  .reduce((acc, c, idx) => ({ ...acc, [c]: idx }), {});
+
+const impl: Validator = {
+  name: 'Mexican Personal Identification',
+  localName: 'Clave Única de Registro de Población',
+  abbreviation: 'CURP',
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value.toLocaleUpperCase();
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    return value;
+  },
+
+  /**
+   * Check if the number is a valid CURP number.
+   * This checks the length, formatting and other contraints. It does not check
+   * for control letter.
+   */
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 18) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    if (!/^[A-Z]{4}[0-9]{6}[A-Z]{6}[0-9A-Z][0-9]$/.test(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!isValidDateCompactYYMMDD(value.substr(4, 6), true)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (nameBlacklist.has(value.substr(0, 4))) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!['H', 'M', 'X'].includes(value[10])) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!validStates.has(value.substr(11, 2))) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const check = value
+      .substr(0, 17)
+      .split('')
+      .reduce(
+        (acc, c, idx) => acc + (checkAlphabetDict[c] ?? 0) * (18 - idx),
+        0,
+      );
+
+    const checkStr = String((10 - (check % 10)) % 10);
+    if (checkStr !== value.substr(17, 1)) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+function getBirthDateImpl(value: string): Date | null {
+  const [, year, mm, dd] = strings.splitAt(value, 4, 6, 8);
+
+  const century = !Number.isNaN(parseInt(value[16], 10)) ? '19' : '20';
+
+  return buildDate(`${century}${year}`, mm, dd);
+}
+
+///
+// Convert the gender value into English values
+//  CURP H = Hombre => Male (M)
+//  CURP M = Mujer  => Female (F)
+//  CURP X = gender neutral (X)
+//
+export function getGender(input: string): 'M' | 'F' | 'X' {
+  const value = impl.compact(input)[10];
+
+  if (value === 'X') {
+    return 'X';
+  } else if (value === 'H') {
+    return 'M';
+  }
+  return 'F';
+}
+
+export function getBirthDate(input: string): Date | null {
+  const value = impl.compact(input);
+
+  const date = getBirthDateImpl(value);
+
+  return validBirthdate(date) ? date : null;
+}
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/mx/index.ts

@@ -0,0 +1,3 @@
+export * as clabe from './clabe';
+export * as curp from './curp';
+export * as rfc from './rfc';

package/src/mx/rfc.spec.ts

@@ -0,0 +1,69 @@
+import { validate, format } from './rfc';
+
+describe('mx/rfc', () => {
+  it('validate:GODE 561231 GR8', () => {
+    const result = validate('GODE 561231 GR8');
+
+    expect(result.isValid && result.compact).toEqual('GODE561231GR8');
+  });
+
+  it('validate:MAB-930714-8T4', () => {
+    const result = validate('MAB-930714-8T4');
+
+    expect(result.isValid && result.compact).toEqual('MAB9307148T4');
+  });
+
+  it('validate:MHTR93041179A', () => {
+    const result = validate('MHTR93041179A');
+
+    expect(result.isValid && result.compact).toEqual('MHTR93041179A');
+  });
+
+  it('validate:Ñ&T130705MD6', () => {
+    const result = validate('Ñ&T130705MD6');
+
+    expect(result.isValid && result.compact).toEqual('Ñ&T130705MD6');
+  });
+
+  it('validate:  mhtr-93041179a  ', () => {
+    const result = validate('  mhtr-93041179a  ');
+
+    expect(result.isValid && result.compact).toEqual('MHTR93041179A');
+  });
+
+  it('validate:SALC7304253S0', () => {
+    const result = validate('SALC7304253S0');
+
+    expect(result.isValid && result.compact).toEqual('SALC7304253S0');
+  });
+
+  // it('validate:XEXX010101000', () => {
+  //   const result = validate('XEXX010101000');
+
+  //   expect(result.isValid && result.compact).toEqual('XEXX010101000');
+  // });
+
+  it('validate:RET130705MD5', () => {
+    const result = validate('RET130705MD5');
+
+    expect(result.isValid && result.compact).toEqual('RET130705MD5');
+  });
+
+  it('validate:COMG-600703', () => {
+    const result = validate('COMG-600703');
+
+    expect(result.isValid && result.compact).toEqual('COMG600703');
+  });
+
+  it('validate:VACE-460910-SX6', () => {
+    const result = validate('VACE-460910-SX6');
+
+    expect(result.isValid).toEqual(false);
+  });
+
+  it('format:GODE561231GR8', () => {
+    const result = format('GODE561231GR8');
+
+    expect(result).toEqual('GODE 561231 GR8');
+  });
+});