stdnum 1.10.0 → 1.10.2

package/src/eg/tn.ts

@@ -0,0 +1,96 @@
+/**
+ * Tax Registration Number (الرقم الضريبي, Egypt tax number).
+ *
+ * This number consists of 9 digits, usually separated into three groups
+ * using hyphens to make it easier to read, like XXX-XXX-XXX.
+ *
+ * Source
+ *   https://emsp.mts.gov.eg:8181/EMDB-web/faces/authoritiesandcompanies/authority/website/SearchAuthority.xhtml?lang=en
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+const ARABIC_NUMBERS_MAP: Record<string, string> = {
+  // Arabic-indic digits.
+  '٠': '0',
+  '١': '1',
+  '٢': '2',
+  '٣': '3',
+  '٤': '4',
+  '٥': '5',
+  '٦': '6',
+  '٧': '7',
+  '٨': '8',
+  '٩': '9',
+  // Extended arabic-indic digits.
+  '۰': '0',
+  '۱': '1',
+  '۲': '2',
+  '۳': '3',
+  '۴': '4',
+  '۵': '5',
+  '۶': '6',
+  '۷': '7',
+  '۸': '8',
+  '۹': '9',
+};
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  // Normalize the arabic characters to ascii digits
+  const norm = input
+    .split('')
+    .map(c => ARABIC_NUMBERS_MAP[c] ?? c)
+    .join('');
+  return strings.cleanUnicode(norm, ' -/');
+}
+
+const impl: Validator = {
+  name: 'Tax Registration Number',
+  localName: 'الرقم الضريبي',
+  abbreviation: 'TN',
+
+  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, 3, 6).join('-');
+  },
+
+  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() };
+    }
+
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/es/cif.spec.ts

@@ -0,0 +1,43 @@
+import { validate, format } from './cif';
+import { InvalidLength, InvalidComponent } from '../exceptions';
+
+describe('es/cif', () => {
+  it('format:J99216582', () => {
+    const result = format('J99216582');
+
+    expect(result).toEqual('J-9921658-2');
+  });
+
+  it.each(['J99216582', 'B86670460', 'Q2876031B', 'N0112768G', 'W8265365J'])(
+    'validate:%s',
+    (cif: string) => {
+      const result = validate(cif);
+
+      expect(result.isValid && result.compact).toEqual(cif);
+    },
+  );
+
+  it('validate:X13585626', () => {
+    const result = validate('X13585626');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:J992165831', () => {
+    const result = validate('J992165831');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:M-1234567-L', () => {
+    const result = validate('M-1234567-L');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:O-1234567-L', () => {
+    const result = validate('O-1234567-L');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});

package/src/es/cif.ts

@@ -0,0 +1,84 @@
+/**
+ * CIF (Código de Identificación Fiscal, Spanish company tax number).
+ *
+ * The CIF is a tax identification number for legal entities. It has 9 digits
+ * where the first digit is a letter (denoting the type of entity) and the
+ * last is a check digit (which may also be a letter).
+ *
+ * Sources:
+ *   https://es.wikipedia.org/wiki/Código_de_identificación_fiscal
+ *
+ * TAX/ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { luhnChecksumDigit } from '../util/checksum';
+
+const entityTypes = 'ABCDEFGHJNPQRSUVW';
+const letterCheckDigits = 'JABCDEFGHI';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const impl: Validator = {
+  name: 'Spanish Company Tax Number',
+  localName: 'Código de Identificación Fiscal',
+  abbreviation: 'CIF',
+  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, 8).join('-');
+  },
+
+  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 [first, body, check] = strings.splitAt(value, 1, 8);
+
+    if (
+      !strings.isdigits(body) ||
+      !entityTypes.includes(first) ||
+      !(strings.isdigits(check) || letterCheckDigits.includes(check))
+    ) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const cs = parseInt(luhnChecksumDigit(body), 10);
+    // Two systems of check digits
+    const possibleCheckDigits = letterCheckDigits[cs] + String(cs);
+
+    if (!possibleCheckDigits.includes(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/es/dni.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './dni';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('es/dni', () => {
+  it('format:54362315K', () => {
+    const result = format('54362315K');
+
+    expect(result).toEqual('54362315-K');
+  });
+
+  it('validate:54362315-K', () => {
+    const result = validate('54362315-K');
+
+    expect(result.isValid && result.compact).toEqual('54362315K');
+  });
+
+  it('validate:54362315', () => {
+    const result = validate('54362315');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:54362315Z', () => {
+    const result = validate('54362315Z');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/es/dni.ts

@@ -0,0 +1,83 @@
+/**
+ * DNI (Documento Nacional de Identidad, Spanish personal identity codes).
+ *
+ * The DNI is a 9 digit number used to identify Spanish citizens. The last
+ * digit is a checksum letter.
+ *
+ * Foreign nationals, since 2010 are issued an NIE (Número de Identificación
+ * de Extranjeros, Foreigner's Identity Number) instead.
+ *
+ * Sources:
+ *   https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/SPAIN-TIN.pdf
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+const checkDigits = 'TRWAGMYFPDXBNJZSQVHLCKE';
+
+export function calcCheckDigit(value: string): string {
+  return checkDigits[parseInt(value.substr(0, 8), 10) % 23];
+}
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const impl: Validator = {
+  name: 'Spanish Personal Identify Code',
+  localName: 'Documento Nacional de Identidad',
+  abbreviation: 'DNI',
+  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, 8).join('-');
+  },
+
+  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 [body, check] = strings.splitAt(value, 8);
+
+    if ('KLM'.includes(body[0]) && strings.isdigits(body.substring(1))) {
+      // Currently no test data for these cases, so
+      // we're assuming they're good based on format
+    } else if (!strings.isdigits(body)) {
+      // Not all digits in the body, it's not valid
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    } else if (calcCheckDigit(body) !== check) {
+      // Check the checksum on a non-[KLM] person
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/es/index.ts

@@ -0,0 +1,5 @@
+export * as cif from './cif';
+export * as dni from './dni';
+export * as nie from './nie';
+export * as nif from './nif';
+export * as nss from './nss';

package/src/es/nie.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './nie';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('es/nie', () => {
+  it('format:x-2482300w', () => {
+    const result = format('x-2482300w');
+
+    expect(result).toEqual('X-2482300-W');
+  });
+
+  it('validate:x-2482300w', () => {
+    const result = validate('x-2482300w');
+
+    expect(result.isValid && result.compact).toEqual('X2482300W');
+  });
+
+  it('validate:X2482300', () => {
+    const result = validate('X2482300');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:x-2482300a', () => {
+    const result = validate('x-2482300a');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/es/nie.ts

@@ -0,0 +1,79 @@
+/**
+ * NIE (Número de Identificación de Extranjero, Spanish foreigner number).
+ *
+ * The NIE is an identification number for foreigners. It is a 9 digit number
+ * where the first digit is either X, Y or Z and last digit is a checksum
+ * letter.
+ *
+ * Sources:
+ *    https://es.wikipedia.org/wiki/N%C3%BAmero_de_identidad_de_extranjero
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import * as dni from './dni';
+import { Validator, ValidateReturn } from '../types';
+
+const checkDigits = 'XYZ';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const impl: Validator = {
+  name: 'Spanish Foreign Number',
+  localName: 'Número de Identificación de Extranjero',
+  abbreviation: 'NIE',
+  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, 8).join('-');
+  },
+
+  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 [first, body, check] = strings.splitAt(value, 1, 8);
+
+    if (
+      !strings.isdigits(body) ||
+      !checkDigits.includes(first) ||
+      strings.isdigits(check)
+    ) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    if (dni.calcCheckDigit(`${checkDigits.indexOf(first)}${body}`) !== check) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/es/nif.spec.ts

@@ -0,0 +1,52 @@
+import { validate, format } from './nif';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('es/nif', () => {
+  it('format:ES B58378431', () => {
+    const result = format('ES B58378431');
+
+    expect(result).toEqual('B-58378431');
+  });
+
+  it('validate:ES B-58378431', () => {
+    const result = validate('ES B-58378431');
+
+    expect(result.isValid && result.compact).toEqual('B58378431');
+  });
+
+  it('validate:B64717838', () => {
+    const result = validate('B64717838');
+
+    expect(result.isValid && result.compact).toEqual('B64717838');
+  });
+
+  it('validate:54362315K', () => {
+    const result = validate('54362315K');
+
+    expect(result.isValid && result.compact).toEqual('54362315K');
+  });
+
+  it('validate:X-5253868-R', () => {
+    const result = validate('X-5253868-R');
+
+    expect(result.isValid && result.compact).toEqual('X5253868R');
+  });
+
+  it('validate:M-1234567-L', () => {
+    const result = validate('M-1234567-L');
+
+    expect(result.isValid && result.compact).toEqual('M1234567L');
+  });
+
+  it('validate:B647178390', () => {
+    const result = validate('54362315');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:B64717839', () => {
+    const result = validate('B64717839');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/es/nif.ts

@@ -0,0 +1,95 @@
+/**
+ * NIF (Número de Identificación Fiscal, Spanish VAT number).
+ *
+ * The Spanish VAT number is a 9-digit number where either the first, last
+ * digits or both can be letters.
+ * The number is either a DNI (Documento Nacional de Identidad, for
+ *
+ * Spaniards), a NIE (Número de Identificación de Extranjero, for
+ * foreigners) or a CIF (Código de Identificación Fiscal, for legal
+ * entities and others).
+ *
+ * VAT (PERSON/ENTITY)
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import * as nie from './nie';
+import * as dni from './dni';
+import * as cif from './cif';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' -./');
+
+  if (err) {
+    return [value, err];
+  }
+  if (value.startsWith('ES')) {
+    return [value.substr(2), null];
+  }
+
+  return [value, null];
+}
+
+const impl: Validator = {
+  name: 'Spanish VAT Number',
+  localName: 'Número de Identificación Fiscal',
+  abbreviation: 'NIF',
+  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).join('-');
+  },
+
+  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() };
+    }
+
+    if ('KLM'.includes(value[0])) {
+      // K: Spanish younger than 14 year old
+      // L: Spanish living outside Spain without DNI
+      // M: granted the tax to foreigners who have no NIE
+      // these use the old checkdigit algorithm (the DNI one)
+      if (value[value.length - 1] !== dni.calcCheckDigit(value.substr(1))) {
+        return { isValid: false, error: new exceptions.InvalidChecksum() };
+      }
+      return {
+        isValid: true,
+        compact: value,
+        isIndividual: true,
+        isCompany: false,
+      };
+    }
+    if (strings.isdigits(value[0])) {
+      // Natural resident (DNI)
+      return dni.validate(value);
+    }
+    if ('XYZ'.includes(value[0])) {
+      // Foreign natural person (NIE)
+      return nie.validate(value);
+    }
+
+    // Otherwise it has to be a (CIF)
+    return cif.validate(value);
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/es/nss.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './nss';
+import { InvalidLength, InvalidComponent } from '../exceptions';
+
+describe('es/nss', () => {
+  it('format:281234567840', () => {
+    const result = format('281234567840');
+
+    expect('28-1234567840').toEqual(result);
+  });
+
+  it.each(['281234567840'])('validate:%s', (value: string) => {
+    const result = validate(value);
+
+    expect(value).toEqual(result.isValid && result.compact);
+  });
+
+  it('validate:77 12345678 40', () => {
+    const result = validate('77 12345678 40');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:28 12345678 4', () => {
+    const result = validate('28 12345678 4');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+});