stdnum 1.10.0 → 1.10.1

package/src/fi/hetu.spec.ts

@@ -0,0 +1,37 @@
+import { validate, format } from './hetu';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('fi/hetu', () => {
+  it('format:131052-308T', () => {
+    const result = format('131052-308T');
+
+    expect(result).toEqual('131052-308T');
+  });
+
+  it('validate:131052-308T', () => {
+    const result = validate('131052-308T');
+
+    expect(result.isValid && result.compact).toEqual('131052-308T');
+  });
+
+  test.each(['131022B3082', '131052X308T', '131052-308T'])(
+    '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:131052-308U', () => {
+    const result = validate('131052-308U');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/fi/hetu.ts

@@ -0,0 +1,108 @@
+/**
+ * HETU (Henkilötunnus, Finnish personal identity code).
+ *
+ * Module for handling Finnish personal identity codes (HETU, Henkilötunnus).
+ * See https://www.vaestorekisterikeskus.fi/default.aspx?id=45 for checksum
+ * calculation details and https://tarkistusmerkit.teppovuori.fi/tarkmerk.htm#hetu1
+ * for historical details.
+ *
+ * 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 CHECK_ALPHA = '0123456789ABCDEFHJKLMNPRSTUVWXY';
+const CENTURY: Record<string, string> = {
+  '+': '18',
+  '-': '19',
+  Y: '19',
+  X: '19',
+  W: '19',
+  V: '19',
+  U: '19',
+  A: '20',
+  B: '20',
+  C: '20',
+  D: '20',
+  E: '20',
+  F: '20',
+};
+const VALID_CENTURY = Object.keys(CENTURY);
+
+const impl: Validator = {
+  name: 'Finnish Personal Identity Code',
+  localName: 'Henkilötunnus',
+  abbreviation: 'HETU',
+
+  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() };
+    }
+
+    const [front, , back, check2] = strings.splitAt(value, 6, 7, -1);
+    if (
+      !strings.isdigits(front) ||
+      !strings.isdigits(back) ||
+      !CHECK_ALPHA.includes(check2)
+    ) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!VALID_CENTURY.includes(value[6])) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [dd, mm, yy, century, person, check] = strings.splitAt(
+      value,
+      2,
+      4,
+      6,
+      7,
+      10,
+    );
+    if (!isValidDate(`${CENTURY[century]}${yy}`, mm, dd, true)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const checkable = `${dd}${mm}${yy}${person}`;
+    if (CHECK_ALPHA[parseInt(checkable, 10) % CHECK_ALPHA.length] !== 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/fi/index.ts

@@ -0,0 +1,3 @@
+export * as alv from './alv';
+export * as hetu from './hetu';
+export * as ytunnus from './ytunnus';

package/src/fi/ytunnus.spec.ts

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

package/src/fi/ytunnus.ts

@@ -0,0 +1,49 @@
+/**
+ * Y-tunnus (Finnish business identifier).
+ *
+ *  The number is an 8-digit code with a weighted checksum.
+ *
+ * ENTITY
+ */
+
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { validate as alvValidate } from './alv';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const impl: Validator = {
+  name: 'Finnish Business Identifier',
+  localName: 'Yritys- ja yhteisötunnus',
+  abbreviation: 'Y-tunnus',
+  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 };
+    }
+
+    return alvValidate(value);
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/fo/index.ts

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

package/src/fo/vn.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './vn';
+import { InvalidLength, InvalidFormat } from '../exceptions';
+
+describe('fo/vn', () => {
+  it('format:623857', () => {
+    const result = format('623857');
+
+    expect(result).toEqual('623857');
+  });
+
+  it('fvalidate:623857', () => {
+    const result = validate('623857');
+
+    expect(result.isValid && result.compact).toEqual('623857');
+  });
+
+  test.each(['623857', '33 28 28', '563.609'])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate:62385', () => {
+    const result = validate('62385');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:62385A', () => {
+    const result = validate('62385A');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+});

package/src/fo/vn.ts

@@ -0,0 +1,71 @@
+/**
+ * V-number (Vinnutal, Faroe Islands tax number).
+ *
+ * In the Faroe Islands the legal persons TIN equals the V number issued by the
+ * Faroese Tax Administration. It is a consecutive number.
+ *
+ * Source
+ *   https://www.taks.fo/fo/borgari/bolkar/at-stovna-virki/
+ *   https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Faroe-islands-TIN.pdf
+ *
+ * ENTITY/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 validRe = /^[PCGQV]{1}00[A-Z0-9]{8}$/;
+
+// const ALPHABET = '0123456789X';
+
+const impl: Validator = {
+  name: 'Vinnutal',
+  localName: 'NAME',
+  abbreviation: 'VN',
+
+  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 !== 6) {
+      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/fr/index.ts

@@ -0,0 +1,5 @@
+export * as nif from './nif';
+export * as nir from './nir';
+export * as siren from './siren';
+export * as siret from './siret';
+export * as tva from './tva';

package/src/fr/nif.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './nif';
+import { InvalidComponent, InvalidLength } from '../exceptions';
+
+describe('fr/nif', () => {
+  it('format:0701987765432', () => {
+    const result = format('0701987765432');
+
+    expect(result).toEqual('07 01 987 765 432');
+  });
+
+  test.each(['3023217600053', '0701987765493'])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid && result.compact).toEqual(value);
+  });
+
+  test.each(['0000000000000'])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(false);
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:9701987765432', () => {
+    const result = validate('9701987765432');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});

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;