stdnum 1.10.0 → 1.10.1

package/src/cn/uscc.ts

@@ -0,0 +1,110 @@
+/**
+ * USCC (Unified Social Credit Code, 统一社会信用代码, China tax number).
+ *
+ * This number consists of 18 digits or uppercase English letters (excluding the
+ * letters I, O, Z, S, V). The number is comprised of several parts:
+ *
+ *   Digit 1 represents the registering authority,
+ *   Digit 2 represents the registered entity type,
+ *   Digits 3 through 8 represent the registering region code,
+ *   Digits 9 through 17 represent the organisation code,
+ *   Digit 18 is a check digit (either a number or letter).
+ *
+ * The registering authority digit most often is a 9, which represents the State
+ * Administration for Industry and Commerce (SAIC) as the registering authority.
+ *
+ * The registered entity type indicates the type of business (or entity). The
+ * most common entity types in China are:
+ *
+ *   Wholly Foreign-Owned Enterprises (WFOE): 外商独资企业
+ *   Joint Ventures (JV): 合资
+ *   Representative Office: 代表处
+ *   State-Owned Enterprise (SOE): 国有企业
+ *   Private Enterprise: 民营企业
+ *   Individually-Owned: 个体户
+ *
+ * The registering region code, sometimes referred to as the "administrative
+ * division code", is a string of six numbers that indicates where the company
+ * is registered. It roughly follows the organisation of the official Chinese
+ * regions.
+ *
+ * The organisation code comes directly from the China Organization Code
+ * certificate, an alternative document to the China Business License. It can
+ * contain letters or digits.
+ *
+ * SOURCES
+ *    https://zh.wikipedia.org/wiki/统一社会信用代码
+ *    https://zh.wikipedia.org/wiki/校验码
+ *    https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/China-TIN.pdf
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const alphabet = '0123456789ABCDEFGHJKLMNPQRTUWXY';
+
+const impl: Validator = {
+  name: 'Chinese Unified Social Credit Code',
+  localName: '统一社会信用代码',
+  abbreviation: 'USCC',
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value;
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    return value;
+  },
+
+  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() };
+    }
+    const [front, back, check] = strings.splitAt(value, 8, 17);
+    if (!strings.isdigits(front)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (back.split('').some(v => !alphabet.includes(v))) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const digit = weightedSum(value.substr(0, 17), {
+      weights: [1, 3, 9, 27, 19, 26, 16, 17, 20, 29, 25, 13, 8, 24, 10, 30, 28],
+      modulus: 31,
+      alphabet,
+    });
+
+    if (alphabet[31 - digit] !== check) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: true,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/co/index.ts

@@ -0,0 +1 @@
+export * as nit from './nit';

package/src/co/nit.spec.ts

@@ -0,0 +1,40 @@
+import { validate, format } from './nit';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('co/nit', () => {
+  it('format:213.123.4321', () => {
+    const result = format('213.123.4321');
+
+    expect(result).toEqual('213.123.432-1');
+  });
+
+  it('validate:213.123.432-1', () => {
+    const result = validate('213.123.432-1');
+
+    expect(result.isValid && result.compact).toEqual('2131234321');
+  });
+
+  it('validate:10184648519', () => {
+    const result = validate('10184648519');
+
+    expect(result.isValid && result.compact).toEqual('10184648519');
+  });
+
+  it('validate:900544472-2', () => {
+    const result = validate('900544472-2');
+
+    expect(result.isValid && result.compact).toEqual('9005444722');
+  });
+
+  it('validate:21312', () => {
+    const result = validate('21312');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:2131234325', () => {
+    const result = validate('2131234325');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/co/nit.ts

@@ -0,0 +1,85 @@
+/**
+ *
+ * Columbian Número de Identificación Tributaria
+ *
+ * The Tax Identification Number (NIT) is a unique Colombian number, assigned by the DIAN (Dirección
+ * de Impuestos y Aduanas Nacionales de Colombia) when the entity is registered in the
+ * RUT (Registro Único Tributario).
+ *
+ * Sources:
+ *   https://es.wikipedia.org/wiki/N%C3%BAmero_de_Identificaci%C3%B3n_Tributaria
+ *
+ * PERSON/ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ',.- ');
+}
+
+const impl: Validator = {
+  name: 'Colombian Tax Identification Number',
+  localName: 'Número de Identificación Tributaria',
+  abbreviation: 'NIT',
+
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value.toLocaleUpperCase();
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    const [p1, p2, p3, p4] = strings.splitAt(value, 3, 6, 9);
+
+    return `${p1}.${p2}.${p3}-${p4}`;
+  },
+
+  /**
+   * 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 < 8 || value.length > 16) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [front, check] = strings.splitAt(value, -1);
+    const sum = weightedSum(front, {
+      weights: [3, 7, 13, 17, 19, 23, 29, 37, 41, 43, 47, 53, 59, 67, 71],
+      reverse: true,
+      modulus: 11,
+    });
+
+    const digit = '01987654321'[sum];
+    if (check !== digit) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: true,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/cr/cpf.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './cpf';
+import { InvalidLength, InvalidComponent } from '../exceptions';
+
+describe('cr/cpf', () => {
+  it('format:701610395', () => {
+    const result = format('701610395');
+
+    expect(result).toEqual('07-0161-0395');
+  });
+
+  it('format:1-613-584', () => {
+    const result = format('1-613-584');
+
+    expect(result).toEqual('01-0613-0584');
+  });
+
+  it('validate:3-0455-0175', () => {
+    const result = validate('3-0455-0175');
+
+    expect(result.isValid && result.compact).toEqual('0304550175');
+  });
+
+  it('validate:30-1234-1234', () => {
+    const result = validate('30-1234-1234');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+});

package/src/cr/cpf.ts

@@ -0,0 +1,93 @@
+/**
+ * CPF (Cédula de Persona Física, Costa Rica physical person ID number).
+ *
+ * The Cédula de Persona Física (CPF), also known as Cédula de Identidad is an
+ * identifier of physical persons.
+ *
+ * The number consists of 10 digits in the form 0P-TTTT-AAAA where P represents
+ * the province, TTTT represents the volume (tomo) padded with zeroes on the
+ * left, and AAAA represents the entry (asiento) also padded with zeroes on the
+ * left.
+ *
+ * It seems to be usual for the leading zeroes in each of the three parts to be
+ * omitted.
+ *
+ * Source
+ *    https://www.hacienda.go.cr/consultapagos/ayuda_cedulas.htm
+ *    https://www.procomer.com/downloads/quiero/guia_solicitud_vuce.pdf (page 11)
+ *    https://www.hacienda.go.cr/ATV/frmConsultaSituTributaria.aspx
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' ');
+  if (err) {
+    return [value, err];
+  }
+  const parts = value.split('-');
+  if (parts.length === 3) {
+    parts[0] = parts[0].padStart(2, '0');
+    parts[1] = parts[1].padStart(4, '0');
+    parts[2] = parts[2].padStart(4, '0');
+  }
+  const number = parts.join('');
+
+  if (number.length !== 10 && number.length !== 9) {
+    return ['', new exceptions.InvalidLength()];
+  }
+
+  return [number.padStart(10, '0'), err];
+}
+
+const impl: Validator = {
+  name: 'Costa Rica Physical Person ID Number',
+  localName: 'Cédula de Persona Física',
+  abbreviation: 'CPF',
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value;
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    return strings.splitAt(value, 2, 6).join('-');
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 10) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (value[0] !== '0') {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/cr/cpj.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './cpj';
+import { InvalidLength, InvalidComponent } from '../exceptions';
+
+describe('cr/cpj', () => {
+  it('format:4 000 042138', () => {
+    const result = format('4 000 042138');
+
+    expect(result).toEqual('4-000-042138');
+  });
+
+  it('validate:3-101-999999', () => {
+    const result = validate('3-101-999999');
+
+    expect(result.isValid && result.compact).toEqual('3101999999');
+  });
+
+  it('validate:310132541', () => {
+    const result = validate('310132541');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:3-534-123559', () => {
+    const result = validate('3-534-123559');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});

package/src/cr/cpj.ts

@@ -0,0 +1,111 @@
+/**
+ * CPJ (Cédula de Persona Jurídica, Costa Rica tax number).
+ *
+ * The Cédula de Persona Jurídica (CPJ) is an identifier of legal entities for
+ * tax purposes.
+ *
+ * This number consists of 10 digits, the first indicates the class of juridical
+ * person, followed by a 3 digit sequence number identifying the type of
+ * juridical person, followed by 6 digits sequence number assigned by Registro
+ * Nacional de la República de Costa Rica.
+ *
+ * Source
+ *   https://www.hacienda.go.cr/consultapagos/ayuda_cedulas.htm
+ *   https://www.procomer.com/downloads/quiero/guia_solicitud_vuce.pdf (page 11)
+ *   http://www.registronacional.go.cr/personas_juridicas/documentos/Consultas/Listado%20de%20Clases%20y%20Tipos%20Cedulas%20Juridicas.pdf
+ *   https://www.hacienda.go.cr/ATV/frmConsultaSituTributaria.aspx
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+const classTypes: Record<string, string[]> = {
+  '2': ['100', '200', '300', '400'],
+  '3': [
+    '002',
+    '003',
+    '004',
+    '005',
+    '006',
+    '007',
+    '008',
+    '009',
+    '010',
+    '011',
+    '012',
+    '013',
+    '014',
+    '101',
+    '102',
+    '103',
+    '104',
+    '105',
+    '106',
+    '107',
+    '108',
+    '109',
+    '110',
+  ],
+  '4': ['000'],
+  '5': ['001'],
+};
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const impl: Validator = {
+  name: 'Costa Rica Tax Number',
+  localName: 'Cédula de Persona Jurídica',
+  abbreviation: 'CPJ',
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value;
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    return strings.splitAt(value, 1, 4).join('-');
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 10) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const items = classTypes[value[0]];
+    if (!items) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!items.includes(value.substr(1, 3))) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: true,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/cr/cr.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './cr';
+import { InvalidLength, InvalidComponent } from '../exceptions';
+
+describe('cr/cr', () => {
+  it('format:122200569906', () => {
+    const result = format('122200569906');
+
+    expect(result).toEqual('122200569906');
+  });
+
+  it('validate:155812994816', () => {
+    const result = validate('155812994816');
+
+    expect(result.isValid && result.compact).toEqual('155812994816');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:300123456789', () => {
+    const result = validate('300123456789');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});

package/src/cr/cr.ts

@@ -0,0 +1,75 @@
+/**
+ * CR (Cédula de Residencia, Costa Rica foreigners ID number).
+ *
+ * The Cédula de Residencia (CR), also know as DIMEX or Documento de
+ * Identificación Migratorio para Extranjeros, is an identifier of foreigners in
+ * Costa Rica.
+ *
+ * This number consists of 11 or 12 digits in the form 1NNN-CC...C-EE...E where
+ * NNN represents the code of the country the foreigner comes from as specified
+ * by Costa Rica's Dirección General de Migración y Extranjería, CC...C is a
+ * sequence telling how many Cédula de Residencia have been issued in total and
+ * EE...E is a sequence telling how many Cédula de Residencia have been issued
+ * for that particular foreign country.
+ *
+ * Source
+ *   https://www.hacienda.go.cr/consultapagos/ayuda_cedulas.htm
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const impl: Validator = {
+  name: 'Costa Rica Foreigners ID Number',
+  localName: 'Cédula de Residencia',
+  abbreviation: 'CR',
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value;
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    return value;
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 12) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (value[0] !== '1') {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/cr/index.ts

@@ -0,0 +1,3 @@
+export * as cpf from './cpf';
+export * as cpj from './cpj';
+export * as cr from './cr';

package/src/cu/index.ts

@@ -0,0 +1 @@
+export * as ni from './ni';

package/src/cu/ni.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './ni';
+import { InvalidLength, InvalidComponent, InvalidFormat } from '../exceptions';
+
+describe('cu/ni', () => {
+  it('format:91021027775', () => {
+    const result = format('91021027775');
+
+    expect(result).toEqual('91021027775');
+  });
+
+  it('validate:91021027775', () => {
+    const result = validate('91021027775');
+
+    expect(result.isValid && result.compact).toEqual('91021027775');
+  });
+
+  it('validate:91221027775', () => {
+    const result = validate('91221027775');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:9102102777A', () => {
+    const result = validate('9102102777A');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+});