stdnum 1.10.0 → 1.10.1

package/src/ba/jmbg.ts

@@ -0,0 +1,85 @@
+/**
+ * JMBG (Bosnia and Herzegovina Unique Master Citizen Number).
+ *
+ * Source
+ *    https://en.wikipedia.org/wiki/Unique_Master_Citizen_Number#
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { isValidDate, strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { weightedSum } from '../util/checksum';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const impl: Validator = {
+  name: 'Bosnia Unique Master Citizen Number',
+  localName: 'Jedinstveni matični broj građana',
+  abbreviation: 'JMBG',
+  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 !== 13) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    // Question the format starts with this according to SI/EMSO
+    //  -- DDMMYYY (year < 800 ? year+=2000 : year+=1000)
+    // Is this universal?
+    const [dd, mm, yyy] = strings.splitAt(value, 2, 4, 7);
+    const yyyy = `${parseInt(yyy, 10) < 800 ? '2' : '1'}${yyy}`;
+
+    if (!isValidDate(yyyy, mm, dd, true)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [front, check] = strings.splitAt(value, 12);
+
+    const sum =
+      11 -
+      weightedSum(front, {
+        modulus: 11,
+        weights: [7, 6, 5, 4, 3, 2, 7, 6, 5, 4, 3, 2],
+      });
+
+    if (String((sum % 11) % 10) !== 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/be/bis.spec.ts

@@ -0,0 +1,184 @@
+import { validate, format } from './bis';
+import { InvalidLength, InvalidChecksum, InvalidFormat } from '../exceptions';
+
+describe('be/bis', () => {
+  it('format:88 22 29-999.70', () => {
+    const result = format('88 02 29-999.70');
+
+    expect(result).toEqual('88022999970');
+  });
+
+  it('validate:1', () => {
+    const result = validate('1');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:88022999990', () => {
+    // A number that validates for NN, should be invalid
+    const result = validate('88022999990');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:88222999936', () => {
+    // A number with an offset of 20, should be valid assuming 19xx
+    const result = validate('88222999936');
+
+    expect(result.isValid && result.compact).toEqual('88222999936');
+  });
+
+  it('validate:08222999934', () => {
+    // A number with an offset of 20, should be valid assuming 20xx
+    const result = validate('08222999934');
+
+    expect(result.isValid && result.compact).toEqual('08222999934');
+  });
+
+  it('validate:88422999979', () => {
+    // A number with an offset of 40, should be valid assuming 19xx
+    const result = validate('88422999979');
+
+    expect(result.isValid && result.compact).toEqual('88422999979');
+  });
+
+  it('validate:08422999977', () => {
+    // A number with an offset of 40, should be valid assuming 20xx
+    const result = validate('08422999977');
+
+    expect(result.isValid && result.compact).toEqual('08422999977');
+  });
+
+  it('validate:96331699989', () => {
+    // A number with an offset of 20, should be invalid due to invalid month
+    const result = validate('96331699989');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:08222999935', () => {
+    // A number with an offset of 20, should be invalid due to invalid checksum
+    const result = validate('08222999935');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:96531699935', () => {
+    // A number with an offset of 40, should be invalid due to invalid month
+    const result = validate('96531699935');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:08451799971', () => {
+    // A number with an offset of 40, should be invalid due to invalid checksum
+    const result = validate('08451799971');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:92612099915', () => {
+    // A number with an offset of 60, should be invalid due to invalid month
+    const result = validate('92612099915');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:99200199926', () => {
+    // A number with an unknown dob offset by 20, should be valid assuming 19xx
+    const result = validate('99200199926');
+
+    expect(result.isValid && result.compact).toEqual('99200199926');
+  });
+
+  it('validate:01200199934', () => {
+    // A number with an unknown dob offset by 20, should be valid assuming 20xx
+    const result = validate('01200199934');
+
+    expect(result.isValid && result.compact).toEqual('01200199934');
+  });
+
+  it('validate:01200199935', () => {
+    // A number with an unknown dob offset by 20, should be invalid by checksum
+    const result = validate('01200199935');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:99400199969', () => {
+    // A number with an unknown dob offset by 40, should be valid assuming 19xx
+    const result = validate('99400199969');
+
+    expect(result.isValid && result.compact).toEqual('99400199969');
+  });
+
+  it('validate:01451599980', () => {
+    // A number with an unknown dob offset by 40, should be valid assuming 20xx
+    const result = validate('01451599980');
+
+    expect(result.isValid && result.compact).toEqual('01451599980');
+  });
+
+  it('validate:01400199977', () => {
+    // A number with an unknown dob offset by 40, should be valid assuming 20xx
+    const result = validate('01400199977');
+
+    expect(result.isValid && result.compact).toEqual('01400199977');
+  });
+
+  it('validate:01400199981', () => {
+    // A number with an unknown dob offset by 40, should be invalid by checksum
+    const result = validate('01400199981');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:00290199976', () => {
+    // A number that starts with 00 can be valid
+    const result = validate('00290199976');
+
+    expect(result.isValid && result.compact).toEqual('00290199976');
+  });
+
+  it('validate:(unspecified date in current year, offset of 20)', () => {
+    const yy = new Date().getFullYear() % 100;
+    const baseNum = parseInt(`${yy}2000999`, 10);
+    const twoPrefixedBaseNumber = parseInt(`${2}${baseNum}`, 10);
+    const checksum = 97 - (twoPrefixedBaseNumber % 97);
+    const id = `${baseNum}${checksum}`;
+
+    const result = validate(id);
+    expect(result.isValid && result.compact).toEqual(id);
+  });
+
+  it('validate:(unspecified date in current year, offset of 40)', () => {
+    const yy = new Date().getFullYear() % 100;
+    const baseNum = parseInt(`${yy}4000999`, 10);
+    const twoPrefixedBaseNumber = parseInt(`${2}${baseNum}`, 10);
+    const checksum = 97 - (twoPrefixedBaseNumber % 97);
+    const id = `${baseNum}${checksum}`;
+
+    const result = validate(id);
+    expect(result.isValid && result.compact).toEqual(id);
+  });
+
+  it('validate:(unspecified date 100 years ago, offset of 20)', () => {
+    const yy = new Date().getFullYear() % 100;
+    const baseNum = parseInt(`${yy}2000999`, 10);
+    const checksum = 97 - (baseNum % 97);
+    const id = `${baseNum}${checksum}`;
+
+    const result = validate(id);
+    expect(result.isValid && result.compact).toEqual(id);
+  });
+
+  it('validate:(unspecified date 100 years ago, offset of 40)', () => {
+    const yy = new Date().getFullYear() % 100;
+    const baseNum = parseInt(`${yy}4000999`, 10);
+    const checksum = 97 - (baseNum % 97);
+    const id = `${baseNum}${checksum}`;
+
+    const result = validate(id);
+    expect(result.isValid && result.compact).toEqual(id);
+  });
+});

package/src/be/bis.ts

@@ -0,0 +1,85 @@
+/**
+ * The BIS (Belgian Number for Foreigners) is an identifier for individuals such
+ * as cross-border workers who do not have a Belgian National Number. It has the
+ * same format as the Belgian National Number, but the month digits are increased
+ * by 40 if the sex of the person was known when the number was assigned and by
+ * 20 if not.
+ *
+ * Source
+ *  https://fr.wikipedia.org/wiki/Numéro_de_registre_national (Numéro de sécurité sociale)
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import {
+  validStructure,
+  validChecksum,
+  toDateArray,
+} from './personIdentifierHelpers';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -.');
+}
+
+function toDob(firstSix: string): string {
+  const [y, m, d] = toDateArray(firstSix).map(s => parseInt(s, 10));
+  const adjustedDateArrays = [
+    [y, m - 20, d],
+    [y, m - 40, d],
+  ];
+  // Allow 0 because a 0 month indicates an unknown DOB.
+  const dobArray =
+    adjustedDateArrays.find(ada => ada[1] >= 0 && ada[1] <= 12) || [];
+  return dobArray.map(n => `${n}`.padStart(2, '0')).join('');
+}
+
+const impl: Validator = {
+  name: 'Belgian Number for Foreigners',
+  localName: 'Numéro BIS',
+  abbreviation: 'BIS',
+  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 number = impl.compact(input);
+
+    if (!strings.isdigits(number) || parseInt(number, 10) <= 0) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (number.length !== 11) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    if (!validStructure(number, toDob)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (!validChecksum(number, toDob)) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: number,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/be/index.ts

@@ -0,0 +1,4 @@
+export * as bis from './bis';
+export * as insz from './insz';
+export * as nn from './nn';
+export * as vat from './vat';

package/src/be/insz.spec.ts

@@ -0,0 +1,51 @@
+import { validate, format } from './insz';
+import { InvalidLength, InvalidChecksum, InvalidFormat } from '../exceptions';
+
+describe('be/insz', () => {
+  it('format:88 02 29-999.90', () => {
+    const result = format('88 02 29-999.90');
+
+    expect(result).toEqual('88022999990');
+  });
+
+  it('validate:1', () => {
+    const result = validate('1');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:88022999990', () => {
+    // Valid only for NN, returns true
+    const result = validate('88022999990');
+
+    expect(result.isValid && result.compact).toEqual('88022999990');
+  });
+
+  it('validate:88222999936', () => {
+    // Valid only for BIS, returns true
+    const result = validate('88222999936');
+
+    expect(result.isValid && result.compact).toEqual('88222999936');
+  });
+
+  it('validate:88150199951', () => {
+    // Invalid Format for both
+    const result = validate('88150199951');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:08222999935', () => {
+    // Invalid format for NN (month + 20), Invalid checksum for BIS
+    const result = validate('08222999935');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:20070199952', () => {
+    // Invalid checksum for NN, Invalid format for BIS
+    const result = validate('20070199952');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/be/insz.ts

@@ -0,0 +1,55 @@
+/**
+ * The Belgian Social Security Identification Number is an 11 digit number.
+ * It can be either a National Register Number (NN, NISS) or BIS.
+ *
+ * Sources
+ *  https://fr.wikipedia.org/wiki/Numéro_de_registre_national
+ *  https://www2.deloitte.com/content/dam/Deloitte/be/Documents/tax/TaxAlerts/IndividualTaxAlerts/Social%20Security%20alert%20-%20BelgianIDpro%20-%2026%20Nov%202020.pdf
+ *
+ * PERSON
+ */
+
+import { strings } from '../util';
+import { validate as nnValidate } from './nn';
+import { validate as bisValidate } from './bis';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -.');
+}
+
+const impl: Validator = {
+  name: 'Belgian Social Security Identification Number',
+  localName: 'Identificatienummer van de Sociale Zekerheid',
+  abbreviation: 'INSZ, NISS',
+  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 results = [nnValidate(input), bisValidate(input)];
+    const validResult = results.find(r => r.isValid);
+    if (validResult) return validResult;
+
+    // The only case with two different error types is an invalid checksum and an
+    // invalid format. The identifier with the checksum error had correct
+    // formatting, so invalid checksum seems like the more descriptive error.
+
+    const checksumErrorResult = results.find(
+      r => r.error && r.error.name === 'InvalidChecksum',
+    );
+    return checksumErrorResult || results[0];
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/be/nn.spec.ts

@@ -0,0 +1,117 @@
+import { validate, format } from './nn';
+import { InvalidLength, InvalidChecksum, InvalidFormat } from '../exceptions';
+
+describe('be/nn', () => {
+  it('format:88 02 29-999.90', () => {
+    const result = format('88 02 29-999.90');
+
+    expect(result).toEqual('88022999990');
+  });
+
+  it('format:88022999990', () => {
+    const result = format('88022999990');
+
+    expect(result).toEqual('88022999990');
+  });
+
+  it('validate:1', () => {
+    const result = validate('1');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:88022999990', () => {
+    const result = validate('88022999990');
+
+    expect(result.isValid && result.compact).toEqual('88022999990');
+  });
+
+  it('validate:88022999991', () => {
+    const result = validate('88022999991');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:87022999991', () => {
+    const result = validate('87022999991');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  test.each([
+    '88022999297',
+    '85073003328',
+    '20070199922',
+    '20070199951',
+    '80000099902',
+    '00000199938',
+    '99000099913',
+  ])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate:20070199952', () => {
+    const result = validate('20070199952');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:80000099903', () => {
+    const result = validate('80000099903');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:00000199939', () => {
+    const result = validate('00000199939');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:99000099942', () => {
+    const result = validate('99000099942');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:40000100133', () => {
+    const result = validate('40000100133');
+
+    expect(result.isValid && result.compact).toEqual('40000100133');
+  });
+
+  it('validate:00000199938', () => {
+    const result = validate('00000199938');
+
+    expect(result.isValid && result.compact).toEqual('00000199938');
+  });
+
+  it('validate:40000095579', () => {
+    const result = validate('40000095579');
+
+    expect(result.isValid && result.compact).toEqual('40000095579');
+  });
+
+  it('validate:(unspecified date in current year)', () => {
+    const yy = new Date().getFullYear() % 100;
+    const baseNum = parseInt(`${yy}0000999`, 10);
+    const twoPrefixedBaseNumber = parseInt(`${2}${baseNum}`, 10);
+    const checksum = 97 - (twoPrefixedBaseNumber % 97);
+    const id = `${baseNum}${checksum}`;
+
+    const result = validate(id);
+    expect(result.isValid && result.compact).toEqual(id);
+  });
+
+  it('validate:(unspecified date 100 years ago)', () => {
+    const yy = new Date().getFullYear() % 100;
+    const baseNum = parseInt(`${yy}0000999`, 10);
+    const checksum = 97 - (baseNum % 97);
+    const id = `${baseNum}${checksum}`;
+
+    const result = validate(id);
+    expect(result.isValid && result.compact).toEqual(id);
+  });
+});

package/src/be/nn.ts

@@ -0,0 +1,77 @@
+/**
+ * NN, NISS, RRN (Belgian national number).
+ *
+ * The national registration number (Rijksregisternummer, Numéro de registre
+ * national, Nationalregisternummer) is a unique identification number of
+ * natural persons who are registered in Belgium.
+ *
+ * The number consists of 11 digits and includes the person's date of birth and
+ * gender. It encodes the date of birth in the first 6 digits in the format
+ * YYMMDD. The following 3 digits represent a counter of people born on the same
+ * date, seperated by sex (odd for male and even for females respectively). The
+ * final 2 digits form a check number based on the 9 preceding digits.
+ *
+ * Source
+ *  https://nl.wikipedia.org/wiki/Rijksregisternummer
+ *  https://fr.wikipedia.org/wiki/Numéro_de_registre_national
+ *  https://www.ibz.rrn.fgov.be/fileadmin/user_upload/nl/rr/instructies/IT-lijst/IT000_Rijksregisternummer.pdf
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { validStructure, validChecksum } from './personIdentifierHelpers';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -.');
+}
+
+const impl: Validator = {
+  name: 'Belgian National Number',
+  localName: 'Numéro National',
+  abbreviation: 'NN, RN',
+  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 = impl.compact(input);
+
+    if (!strings.isdigits(value) || parseInt(value, 10) <= 0) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (value.length !== 11) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    if (!validStructure(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (!validChecksum(value)) {
+      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;