stdnum 1.10.0 → 1.10.2

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);
+  });
+});

package/src/cu/ni.ts

@@ -0,0 +1,74 @@
+/**
+ * NI (Número de identidad, Cuban identity card numbers).
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { isValidDate, strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' ');
+}
+
+const impl: Validator = {
+  name: 'Cuban Identity Card Number',
+  localName: 'Número de Identidad',
+  abbreviation: 'NI',
+  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 !== 11) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [yy, mm, dd, cen] = strings.splitAt(value, 2, 4, 6, 7);
+    let year;
+    if ('012345'.includes(cen)) {
+      year = `19${yy}`;
+    } else if ('678'.includes(cen)) {
+      year = `20${yy}`;
+    } else if (cen === '9') {
+      year = `18${yy}`;
+    } else {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    if (!isValidDate(year, mm, dd, true)) {
+      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/cy/index.ts

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

package/src/cy/vat.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './vat';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('cy/vat', () => {
+  it('format:CY-10259033P', () => {
+    const result = format('CY-10259033P');
+
+    expect(result).toEqual('10259033P');
+  });
+
+  it('validate:CY-10259033P', () => {
+    const result = validate('CY-10259033P');
+
+    expect(result.isValid && result.compact).toEqual('10259033P');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:CY-10259033Z', () => {
+    const result = validate('CY-10259033Z');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/cy/vat.ts

@@ -0,0 +1,98 @@
+/**
+ * Αριθμός Εγγραφής Φ.Π.Α. (Cypriot VAT number).
+ *
+ * The Cypriot Αριθμός Εγγραφής Φ.Π.Α. (VAT) number consists of 9 digits
+ * where the last one is a is a letter and functions as a check digit.
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const weights: Record<string, number> = {
+  '0': 1,
+  '1': 0,
+  '2': 5,
+  '3': 7,
+  '4': 9,
+  '5': 13,
+  '6': 15,
+  '7': 17,
+  '8': 19,
+  '9': 21,
+};
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' -');
+
+  if (err !== null) {
+    return [value, err];
+  }
+  if (value.startsWith('CY')) {
+    return [value.substr(2), null];
+  }
+
+  return [value, null];
+}
+
+const impl: Validator = {
+  name: 'Cypriot VAT Number',
+  localName: 'Αριθμός Εγγραφής Φ.Π.Α.',
+  abbreviation: 'ΦΠΑ',
+
+  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 !== 9) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    const [front, check] = strings.splitAt(value, -1);
+    if (!strings.isdigits(front)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!alphabet.includes(check)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const sum = front
+      .split('')
+      .map(v => parseInt(v, 10))
+      .reduce((acc, v, idx) => acc + (idx % 2 === 0 ? weights[v] : v), 0);
+
+    if (alphabet[sum % 26] !== 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/cz/dic.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './dic';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('cz/dic', () => {
+  it('format:CZ 25123891', () => {
+    const result = format('CZ 25123891');
+
+    expect(result).toEqual('25123891');
+  });
+
+  it('validate:CZ 25123891', () => {
+    const result = validate('CZ 25123891');
+
+    expect(result.isValid && result.compact).toEqual('25123891');
+  });
+
+  it('validate:1234567', () => {
+    const result = validate('1234567');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:25123890', () => {
+    const result = validate('25123890');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/cz/dic.ts

@@ -0,0 +1,127 @@
+/**
+ * DIČ (Daňové identifikační číslo, Czech VAT number).
+ *
+ * The number is an 8, 9 or 10 digit code that includes a check digit and is
+ * used to uniquely identify taxpayers for VAT (DPH in Czech). The number can
+ * refer to legal entities (8 digit numbers), individuals with a RČ (the 9 or
+ * 10 digit Czech birth number) or individuals without a RČ (9 digit numbers
+ * that begin with a 6).
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { validate as rcValidate } from './rc';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' -');
+  if (err !== null) {
+    return [value, err];
+  }
+  if (value.startsWith('CZ')) {
+    return [value.substr(2), null];
+  }
+
+  return [value, null];
+}
+
+function checkLegal(value: string): boolean {
+  const [front, check] = strings.splitAt(value, -1);
+
+  const sum = weightedSum(front, {
+    modulus: 11,
+    weights: [8, 7, 6, 5, 4, 3, 2, 1],
+  });
+
+  const v = (11 - sum) % 11;
+
+  return (v === 0 ? '1' : String(v % 10)) === check;
+}
+
+function checkSpecial(value: string): boolean {
+  // check = sum((8 - i) * int(n) for i, n in enumerate(number)) % 11
+
+  // return str((8 - (10 - check) % 11) % 10)
+
+  const [front, check] = strings.splitAt(value, -1);
+
+  const sum = weightedSum(front, {
+    modulus: 11,
+    weights: [8, 7, 6, 5, 4, 3, 2, 1],
+  });
+  const digit = String((8 - ((10 - sum) % 11)) % 10);
+
+  return digit === check;
+}
+
+const impl: Validator = {
+  name: 'Czech VAT Number',
+  localName: 'Daňové identifikační číslo',
+  abbreviation: 'DIČ',
+
+  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 (![8, 9, 10].includes(value.length)) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (value.length === 8) {
+      if (value.startsWith('9')) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+
+      if (!checkLegal(value)) {
+        return { isValid: false, error: new exceptions.InvalidChecksum() };
+      }
+
+      return {
+        isValid: true,
+        compact: value,
+        isIndividual: false,
+        isCompany: true,
+      };
+    }
+    if (value.length === 9 && value.startsWith('6')) {
+      if (!checkSpecial(value)) {
+        return { isValid: false, error: new exceptions.InvalidChecksum() };
+      }
+
+      return {
+        isValid: true,
+        compact: value,
+        isIndividual: false,
+        isCompany: true,
+      };
+    }
+
+    return rcValidate(value);
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/cz/index.ts

@@ -0,0 +1,2 @@
+export * as dic from './dic';
+export * as rc from './rc';

package/src/cz/rc.spec.ts

@@ -0,0 +1,44 @@
+import { validate, format } from './rc';
+import {
+  InvalidLength,
+  InvalidChecksum,
+  InvalidComponent,
+} from '../exceptions';
+
+describe('cz/rc', () => {
+  it('format:7103192745', () => {
+    const result = format('7103192745');
+
+    expect(result).toEqual('710319/2745');
+  });
+
+  it('validate:710319/2745', () => {
+    const result = validate('710319/2745');
+
+    expect(result.isValid && result.compact).toEqual('7103192745');
+  });
+
+  it('validate:991231123', () => {
+    const result = validate('991231123');
+
+    expect(result.isValid && result.compact).toEqual('991231123');
+  });
+
+  it('validate:1103492745', () => {
+    const result = validate('1103492745');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:590312/12', () => {
+    const result = validate('590312/12');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:7103192746', () => {
+    const result = validate('7103192746');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});