stdnum 1.9.16 → 1.10.1

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';

package/src/gb/nino-prefixes.ts

@@ -0,0 +1,245 @@
+// Source: https://webarchive.nationalarchives.gov.uk/ukgwa/20120207170042/http://www.hmrc.gov.uk/softwaredevelopers/rti/mig-rti-nvreq.pdf
+// (Page 46)
+const PREFIXES = new Set([
+  'AA',
+  'AB',
+  'AE',
+  'AH',
+  'AK',
+  'AL',
+  'AM',
+  'AP',
+  'AR',
+  'AS',
+  'AT',
+  'AW',
+  'AX',
+  'AY',
+  'AZ',
+  'BA',
+  'BB',
+  'BE',
+  'BH',
+  'BK',
+  'BL',
+  'BM',
+  'BT',
+  'CA',
+  'CB',
+  'CE',
+  'CH',
+  'CK',
+  'CL',
+  'CR',
+  'EA',
+  'EB',
+  'EE',
+  'EH',
+  'EK',
+  'EL',
+  'EM',
+  'EP',
+  'ER',
+  'ES',
+  'ET',
+  'EW',
+  'EX',
+  'EY',
+  'EZ',
+  'GY',
+  'HA',
+  'HB',
+  'HE',
+  'HH',
+  'HK',
+  'HL',
+  'HM',
+  'HP',
+  'HR',
+  'HS',
+  'HT',
+  'HW',
+  'HX',
+  'HY',
+  'HZ',
+  'JA',
+  'JB',
+  'JC',
+  'JE',
+  'JG',
+  'JH',
+  'JJ',
+  'JK',
+  'JL',
+  'JM',
+  'JN',
+  'JP',
+  'JR',
+  'JS',
+  'JT',
+  'JW',
+  'JX',
+  'JY',
+  'JZ',
+  'KA',
+  'KB',
+  'KE',
+  'KH',
+  'KK',
+  'KL',
+  'KM',
+  'KP',
+  'KR',
+  'KS',
+  'KT',
+  'KW',
+  'KX',
+  'KY',
+  'KZ',
+  'LA',
+  'LB',
+  'LE',
+  'LH',
+  'LK',
+  'LL',
+  'LM',
+  'LP',
+  'LR',
+  'LS',
+  'LT',
+  'LW',
+  'LX',
+  'LY',
+  'LZ',
+  'MA',
+  'MW',
+  'MX',
+  'NA',
+  'NB',
+  'NE',
+  'NH',
+  'NL',
+  'NM',
+  'NP',
+  'NR',
+  'NS',
+  'NW',
+  'NX',
+  'NY',
+  'NZ',
+  'OA',
+  'OB',
+  'OE',
+  'OH',
+  'OK',
+  'OL',
+  'OM',
+  'OP',
+  'OR',
+  'OS',
+  'OX',
+  'PA',
+  'PB',
+  'PC',
+  'PE',
+  'PG',
+  'PH',
+  'PJ',
+  'PK',
+  'PL',
+  'PM',
+  'PN',
+  'PP',
+  'PR',
+  'PS',
+  'PT',
+  'PW',
+  'PX',
+  'PY',
+  'RA',
+  'RB',
+  'RE',
+  'RH',
+  'RK',
+  'RM',
+  'RP',
+  'RR',
+  'RS',
+  'RT',
+  'RW',
+  'RX',
+  'RY',
+  'RZ',
+  'SA',
+  'SB',
+  'SC',
+  'SE',
+  'SG',
+  'SH',
+  'SJ',
+  'SK',
+  'SL',
+  'SM',
+  'SN',
+  'SP',
+  'SR',
+  'SS',
+  'ST',
+  'SW',
+  'SX',
+  'SY',
+  'SZ',
+  'TA',
+  'TB',
+  'TE',
+  'TH',
+  'TK',
+  'TL',
+  'TM',
+  'TP',
+  'TR',
+  'TS',
+  'TT',
+  'TW',
+  'TX',
+  'TY',
+  'TZ',
+  'WA',
+  'WB',
+  'WE',
+  'WK',
+  'WL',
+  'WM',
+  'WP',
+  'YA',
+  'YB',
+  'YE',
+  'YH',
+  'YK',
+  'YL',
+  'YM',
+  'YP',
+  'YR',
+  'YS',
+  'YT',
+  'YW',
+  'YX',
+  'YY',
+  'YZ',
+  'ZA',
+  'ZB',
+  'ZE',
+  'ZH',
+  'ZK',
+  'ZL',
+  'ZM',
+  'ZP',
+  'ZR',
+  'ZS',
+  'ZT',
+  'ZW',
+  'ZX',
+  'ZY',
+]);
+
+export default PREFIXES;

package/src/gb/nino.spec.ts

@@ -0,0 +1,80 @@
+import { validate, format } from './nino';
+import { InvalidLength, InvalidFormat } from '../exceptions';
+
+describe('gb/nino', () => {
+  it('format:HH 012345 D', () => {
+    const result = format('HH 012345 D');
+
+    expect(result).toEqual('HH012345D');
+  });
+
+  it('validate:HH012345D', () => {
+    // A valid number with a suffix
+    const result = validate('HH012345D');
+
+    expect(result.isValid && result.compact).toEqual('HH012345D');
+  });
+
+  it('validate:hh012345d', () => {
+    // A valid number with lowercase letters
+    const result = validate('hh012345d');
+
+    expect(result.isValid && result.compact).toEqual('HH012345D');
+  });
+
+  it('validate:HH012345', () => {
+    // A valid number without a suffix
+    const result = validate('HH012345');
+
+    expect(result.isValid && result.compact).toEqual('HH012345');
+  });
+
+  it('validate:HH01234', () => {
+    // Invalid length, too short
+    const result = validate('HH01234');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:HH0123456D', () => {
+    // Invalid length, too long
+    const result = validate('HH0123456D');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:00012345D', () => {
+    // Invalid numeric prefix, valid numbers, suffix
+    const result = validate('00012345D');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:XO012345D', () => {
+    // Invalid letter, valid numbers, suffix
+    const result = validate('XO012345D');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:XO012345', () => {
+    // Invalid letter, valid numbers, without suffix
+    const result = validate('XO012345');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:HH01A345D', () => {
+    // Valid prefix, invalid numeric section, with suffix
+    const result = validate('HH01A345D');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:HH012345E', () => {
+    // Valid prefix, valid numeric section, invalid suffix
+    const result = validate('HH012345E');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+});

package/src/gb/nino.ts

@@ -0,0 +1,80 @@
+/**
+ * The National Insurance Number (NINO) is a nine character identifier used in
+ * the United Kingdom.
+ *
+ * The first two characters are from an approved list of prefixes, the next
+ * six characters are numbers issued sequentially and the final character is
+ * a letter A-D. The suffix may be omitted if it is not known.
+ *
+ * Source
+ *  https://en.wikipedia.org/wiki/National_Insurance_number
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import PREFIXES from './nino-prefixes';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -.');
+}
+
+function validLength(value: string): boolean {
+  // The suffix letter may be omitted, so we permit a length of 8.
+  return [8, 9].includes(value.length);
+}
+
+const VALID_FORMAT_REGEX = /^([A-Z]{2})\d{6}[A-D]?$/;
+
+function validFormat(value: string): boolean {
+  const matchData = value.toUpperCase().match(VALID_FORMAT_REGEX);
+  return !!matchData && PREFIXES.has(matchData[1]);
+}
+
+const impl: Validator = {
+  name: 'United Kingdom National Insurance Number',
+  localName: 'National Insurance Number',
+  abbreviation: 'NINO',
+
+  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 (!validLength(value)) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!validFormat(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;