stdnum 1.10.0 → 1.10.2

package/src/fr/nif.ts

@@ -0,0 +1,82 @@
+/**
+ * NIF (Numéro d'Immatriculation Fiscale, French tax identification number).
+ *
+ * The NIF (Numéro d'Immatriculation Fiscale, Numéro d'Identité Fiscale or
+ * Numéro d'Identification Fiscale) also known as numéro fiscal de référence or
+ * SPI (Simplification des Procédures d'Identification) is a 13-digit number
+ * issued by the French tax authorities to people for tax reporting purposes.
+ *
+ * Source
+ *   https://ec.europa.eu/taxation_customs/tin/tinByCountry.html
+ *   https://fr.wikipedia.org/wiki/Numéro_d%27Immatriculation_Fiscale#France
+ *
+ * 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: 'French Tax Identification Number',
+  localName: "Numéro d'Immatriculation Fiscale",
+  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, 2, 4, 7, 10).join(' ');
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 13) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [prefix, check] = strings.splitAt(value, 10);
+    const pvalue = parseInt(prefix, 10);
+
+    if (!'0123'.includes(value[0])) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    // A zero value is not a valid value
+    if (pvalue === 0) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    if (String(pvalue % 511).padStart(3, '0') !== 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/fr/nir.spec.ts

@@ -0,0 +1,36 @@
+import { validate, format } from './nir';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('fr/nir', () => {
+  it('format:295109912611193', () => {
+    const result = format('295109912611193');
+
+    expect(result).toEqual('2 95 10 99 126 111 93');
+  });
+
+  test.each(['186022A21532523', '2 95 10 99 126 111 93'])(
+    'validate-list:%s',
+    value => {
+      const result = validate(value);
+      expect(result.isValid).toEqual(true);
+    },
+  );
+
+  it('validate:2 95 10 99 126 111 93', () => {
+    const result = validate('2 95 10 99 126 111 93');
+
+    expect(result.isValid && result.compact).toEqual('295109912611193');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:295109912611199', () => {
+    const result = validate('295109912611199');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/fr/nir.ts

@@ -0,0 +1,98 @@
+/**
+ * NIR (French personal identification number).
+ *
+ * The NIR (Numero d'Inscription au Repertoire national d'identification des
+ * personnes physiques) is used to identify persons in France. It is popularly
+ * known as the "social security number" and sometimes referred to as an INSEE
+ * number. All persons born in France are registered in the Repertoire national
+ * d'identification des personnes physiques (RNIPP) and assigned a NIR.
+ *
+ * The number consists of 15 digits: the first digit indicates the gender,
+ * followed by 2 digits for the year or birth, 2 for the month of birth, 5 for
+ * the location of birth (COG), 3 for a serial and 2 check digits.
+ *
+ * More information:
+ *   https://www.insee.fr/en/metadonnees/definition/c1409
+ *   https://en.wikipedia.org/wiki/INSEE_code
+ *   http://resoo.org/docs/_docs/regles-numero-insee.pdf
+ *   https://fr.wikipedia.org/wiki/Numéro_de_sécurité_sociale_en_France
+ *   https://xml.insee.fr/schema/nir.html
+ *
+ * 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: 'French Personal Identification Number',
+  localName: 'Numéro d’Inscription au RNIPP',
+  abbreviation: 'NIR',
+  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, 3, 5, 7, 10, 13).join(' ');
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 15) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    const [pre, dept, post, check] = strings.splitAt(value, 5, 7, 13);
+
+    if (
+      !strings.isdigits(pre) ||
+      !strings.isdigits(post) ||
+      !strings.isdigits(check)
+    ) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    let add = '';
+    if (dept === '2A') {
+      add = '19';
+    } else if (dept === '2B') {
+      add = '18';
+    } else if (strings.isdigits(dept)) {
+      add = dept;
+    } else {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const sum = parseInt(`${pre}${add}${post}`, 10) % 97;
+
+    if (String(97 - sum).padStart(2, '0') !== 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/fr/siren.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './siren';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('fr/siren', () => {
+  it('format:552 008 443', () => {
+    const result = format('552008443');
+
+    expect(result).toEqual('552 008 443');
+  });
+
+  it('validate:552 008 443', () => {
+    const result = validate('552 008 443');
+
+    expect(result.isValid && result.compact).toEqual('552008443');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:552 008 442', () => {
+    const result = validate('552 008 442');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/fr/siren.ts

@@ -0,0 +1,68 @@
+/**
+ * SIREN (a French company identification number).
+ *
+ * The SIREN (Système d'Identification du Répertoire des Entreprises) is a 9
+ * digit number used to identify French companies. The Luhn checksum is used
+ * to validate the numbers.
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { luhnChecksumValidate } from '../util/checksum';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' .');
+}
+
+const impl: Validator = {
+  name: 'French Company Identification Number',
+  localName: "Système d'Identification du Répertoire des Entreprises",
+  abbreviation: 'SIREN',
+
+  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() };
+    }
+
+    if (!luhnChecksumValidate(value)) {
+      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/fr/siret.spec.ts

@@ -0,0 +1,38 @@
+import { validate, format } from './siret';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('fr/siret', () => {
+  it('format:552 008443', () => {
+    const result = format('73282932000074');
+
+    expect(result).toEqual('732 829 320 00074');
+  });
+
+  test.each([
+    '73282932000074',
+    '356 000 000 09075',
+    '35600000000048',
+    '35600000049837',
+  ])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+  // it('validate:73282932000074', () => {
+  //   const result = validate('73282932000074');
+
+  //   expect(result.isValid && result.compact).toEqual('73282932000074');
+  // });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  test.each(['35600000049838', '73282932000075'])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/fr/siret.ts

@@ -0,0 +1,79 @@
+/**
+ * SIRET (a French company establishment identification number).
+ *
+ * The SIRET (Système d'Identification du Répertoire des Établissements)
+ * is a 14 digit number used to identify French companies' establishments
+ * and facilities. The Luhn checksum is used to validate the numbers (except
+ * for La Poste).
+ *
+ * Sources:
+ *   https://fr.wikipedia.org/wiki/Système_d'identification_du_répertoire_des_établissements
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { luhnChecksumValidate, weightedSum } from '../util/checksum';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -/');
+}
+
+const impl: Validator = {
+  name: 'French Company Establishment Identification Number',
+  localName: "Système d'Identification du Répertoire des Établissements",
+  abbreviation: 'SIRET',
+  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, 9).join(' ');
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 14) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (value.startsWith('356000000') && value !== '35600000000048') {
+      const sum = weightedSum(value, {
+        weights: [1],
+        modulus: 5,
+      });
+      if (sum !== 0) {
+        return { isValid: false, error: new exceptions.InvalidChecksum() };
+      }
+    } else if (!luhnChecksumValidate(value)) {
+      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/fr/tva.spec.ts

@@ -0,0 +1,40 @@
+import { validate, format } from './tva';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('fr/tva', () => {
+  it('format:Fr 40 303 265045', () => {
+    const result = format('Fr 40 303 265045');
+
+    expect(result).toEqual('40 303 265 045');
+  });
+
+  it('validate:Fr 40 303 265 045', () => {
+    const result = validate('Fr 40 303 265 045');
+
+    expect(result.isValid && result.compact).toEqual('40303265045');
+  });
+
+  test.each([
+    '40303265045',
+    '23334175221',
+    'K7399859412',
+    '4Z123456782',
+    'FR84323140392',
+  ])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:84 323 140 391', () => {
+    const result = validate('84 323 140 391');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/fr/tva.ts

@@ -0,0 +1,125 @@
+/**
+ * n° TVA (taxe sur la valeur ajoutée, French VAT number).
+ *
+ * The n° TVA (Numéro d'identification à la taxe sur la valeur ajoutée) is the
+ * SIREN (Système d’Identification du Répertoire des Entreprises) prefixed by
+ * two digits. In old style numbers the two digits are numeric, with new
+ * style numbers at least one is a alphabetic.
+ *
+ * Source:
+ *   https://wiki.scn.sap.com/wiki/display/CRM/France
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import * as siren from './siren';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' -.');
+
+  if (err !== null) {
+    return [value, err];
+  }
+  if (value.startsWith('FR')) {
+    return [value.substr(2), null];
+  }
+
+  return [value, null];
+}
+
+// the valid characters for the first two digits (O and I are missing)
+const alphabet = '0123456789ABCDEFGHJKLMNPQRSTUVWXYZ';
+
+const impl: Validator = {
+  name: 'French VAT Number',
+  localName: "Numéro d'Identification à la Taxe sur la Valeur Ajoutée",
+  abbreviation: 'n°TVA',
+  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, 5, 8).join(' ');
+  },
+
+  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() };
+    }
+    const [check, back] = strings.splitAt(value, 2);
+    if (!alphabet.includes(check[0]) || !alphabet.includes(check[1])) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!strings.isdigits(back)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    // numbers from Monaco are valid TVA but not SIREN
+    if (value.substring(2, 5) !== '000') {
+      const r = siren.validate(value.substr(2));
+      if (!r.isValid) {
+        return r;
+      }
+    }
+
+    if (strings.isdigits(check)) {
+      const sum = (12 + 3 * (parseInt(back, 10) % 97)) % 97;
+
+      if (String(sum) !== check) {
+        return { isValid: false, error: new exceptions.InvalidChecksum() };
+      }
+    } else {
+      // const FACTORS = {
+      //   1: [24, 10],
+      //   0: [34, 100],
+      // };
+      // const factors = FACTORS[strings.isdigits(check[0]) ? 1 : 0];
+
+      // const cvalue =
+      //   alphabet.indexOf(check[0]) * factors[0] +
+      //   alphabet.indexOf(check[1]) -
+      //   factors[1];
+
+      const c0 = alphabet.indexOf(check[0]);
+      const c1 = alphabet.indexOf(check[1]);
+
+      let cvalue;
+      if (c0 < 10) {
+        cvalue = c0 * 24 + c1 - 10;
+      } else {
+        cvalue = c0 * 34 + c1 - 100;
+      }
+
+      const sum = (parseInt(back, 10) + 1 + Math.floor(cvalue / 11)) % 11;
+      const digit = cvalue % 11;
+      if (sum !== digit) {
+        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/gb/index.ts

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