stdnum 1.9.16 → 1.10.1

package/src/nl/onderwijsnummer.ts

@@ -0,0 +1,77 @@
+/**
+ * Onderwijsnummer (the Dutch student identification number).
+ *
+ * The onderwijsnummers (education number) is very similar to the BSN (Dutch
+ * citizen identification number), but is for students without a BSN. It uses a
+ * checksum mechanism similar to the BSN.
+ *
+ * Source:
+ *   https://nl.wikipedia.org/wiki/Onderwijsnummer
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { 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: 'Dutch Student Identification Number',
+  localName: 'Onderwijsnummer',
+  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, 4, 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 (value.substr(0, 2) !== '10') {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const sum = weightedSum(value, {
+      weights: [9, 8, 7, 6, 5, 4, 3, 2, -1],
+      modulus: 10000,
+    });
+
+    if (sum % 11 !== 5) {
+      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/no/fodselsnummer.spec.ts

@@ -0,0 +1,56 @@
+import { validate, format } from './fodselsnummer';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('no/fodselsnummer', () => {
+  it('format:15108695088', () => {
+    const result = format('15108695088');
+
+    expect(result).toEqual('151086 95088');
+  });
+
+  test.each([
+    '11111598403',
+    '23114048690',
+    '15108695088',
+    // from norsk-validator
+    '01010750160',
+    '30042099941',
+    '22052099424',
+    '09062099345',
+    '020161 26007',
+  ])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  test.each([
+    '45014054018',
+    // from norsk-validator
+    '11111234567',
+    '1234123456',
+    '',
+  ])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(false);
+  });
+
+  it('validate:151086 95088', () => {
+    const result = validate('151086 95088');
+
+    expect(result.isValid && result.compact).toEqual('15108695088');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:15108695077', () => {
+    const result = validate('15108695077');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/no/fodselsnummer.ts

@@ -0,0 +1,118 @@
+/**
+ * Fødselsnummer (Norwegian birth number, the national identity number).
+ *
+ * The Fødselsnummer is an eleven-digit number that is built up of the date of
+ * birth of the person, a serial number and two check digits.
+ *
+ * Source:
+ *   https://no.wikipedia.org/wiki/F%C3%B8dselsnummer
+ *   https://en.wikipedia.org/wiki/National_identification_number#Norway
+ *
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { isValidDate, strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -:');
+}
+
+function checkBirthdate(value: string) {
+  // eslint-disable-next-line prefer-const
+  let [dd, mm, yy, rest] = strings
+    .splitAt(value, 2, 4, 6, 9)
+    .map(v => parseInt(v, 10));
+
+  // Correct the birth day for D-numbers. These have a modified first digit.
+  // https://no.wikipedia.org/wiki/F%C3%B8dselsnummer#D-nummer
+  if (dd > 40) {
+    dd -= 40;
+  }
+  // Correct the birth month for H-numbers. These have a modified third digit.
+  // https://no.wikipedia.org/wiki/F%C3%B8dselsnummer#H-nummer
+  if (mm > 40) {
+    mm -= 40;
+  }
+  if (rest < 500) {
+    yy += 1900;
+  } else if (rest < 750 && yy > 54) {
+    yy += 1800;
+  } else if (rest < 1000 && yy < 40) {
+    yy += 2000;
+  } else if (rest >= 900 && rest < 1000 && yy >= 40) {
+    yy += 1900;
+  } else {
+    return false;
+  }
+
+  return isValidDate(String(yy), String(mm), String(dd), true);
+}
+
+const impl: Validator = {
+  name: 'Norwegian National Identity Number',
+  localName: 'Fødselsnummer',
+  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, 6).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() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!checkBirthdate(value)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [front1, check1] = strings.splitAt(value, 9, 10);
+    const [front2, check2] = strings.splitAt(value, 10);
+
+    const sum1 = weightedSum(front1, {
+      weights: [3, 7, 6, 1, 8, 9, 4, 5, 2],
+      modulus: 11,
+    });
+    const sum2 = weightedSum(front2, {
+      weights: [5, 4, 3, 2, 7, 6, 5, 4, 3, 2],
+      modulus: 11,
+    });
+
+    if (
+      String((11 - sum1) % 11) !== check1 ||
+      String((11 - sum2) % 11) !== check2
+    ) {
+      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/no/index.ts

@@ -0,0 +1,4 @@
+export * as fodselsnummer from './fodselsnummer';
+export * as kontonr from './kontonr';
+export * as mva from './mva';
+export * as orgnr from './orgnr';

package/src/no/kontonr.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './kontonr';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('no/kontonr', () => {
+  it('format:86011117947', () => {
+    const result = format('86011117947');
+
+    expect(result).toEqual('8601.11.17947');
+  });
+
+  it('validate:8601 11 17947', () => {
+    const result = validate('8601 11 17947');
+
+    expect(result.isValid && result.compact).toEqual('86011117947');
+  });
+
+  it('validate:0000.4090403', () => {
+    const result = validate('0000.4090403');
+
+    expect(result.isValid && result.compact).toEqual('4090403');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:8601 11 17949', () => {
+    const result = validate('8601 11 17949');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/no/kontonr.ts

@@ -0,0 +1,84 @@
+/**
+ *  Konto nr. (Bank Account Number) IBAN?
+ *
+ */
+
+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> {
+  const [value, err] = strings.cleanUnicode(input, ' -.');
+
+  if (err) {
+    return [value, err];
+  }
+
+  if (value.startsWith('0000')) {
+    return [value.substr(4), null];
+  }
+
+  return [value, null];
+}
+
+const impl: Validator = {
+  name: 'Norwegian Bank Account Number',
+  localName: 'Kontonummer',
+  abbreviation: 'Konto Nr.',
+  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.padStart(11, '0'), 4, 6).join('.');
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 11 && value.length !== 7) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (value.length === 7 && !luhnChecksumValidate(value)) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+    if (value.length === 11) {
+      const [front, check] = strings.splitAt(value, -1);
+
+      const sum = weightedSum(front, {
+        weights: [6, 7, 8, 9, 4, 5, 6, 7, 8, 9],
+        modulus: 11,
+      });
+
+      if (String(sum) !== 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/no/mva.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './mva';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('no/mva', () => {
+  it('format:NO995525828MVA', () => {
+    const result = format('NO995525828MVA');
+
+    expect(result).toEqual('NO 995 525 828 MVA');
+  });
+
+  it('validate:NO 995 525 828 MVA', () => {
+    const result = validate('NO 995 525 828 MVA');
+
+    expect(result.isValid && result.compact).toEqual('995525828MVA');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:NO 995 525 829 MVA', () => {
+    const result = validate('NO 995 525 829 MVA');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/no/mva.ts

@@ -0,0 +1,80 @@
+/**
+ * MVA (Merverdiavgift, Norwegian VAT number).
+ *
+ * The VAT number is the standard Norwegian organisation number
+ * (Organisasjonsnummer) with 'MVA' as suffix.
+ *
+ * Source
+ *    https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Norway-TIN.pdf
+ *
+ * PERSON/ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { 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, ' ', 'NO');
+}
+
+const impl: Validator = {
+  name: 'Norwegian VAT Number',
+  localName: 'Merverdiavgift',
+  abbreviation: 'MVA',
+
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value;
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    return `NO ${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 !== 12) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value.substr(0, 9))) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, end] = strings.splitAt(value, 9);
+    if (end !== 'MVA') {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const sum = weightedSum(front, {
+      weights: [3, 2, 7, 6, 5, 4, 3, 2, 1],
+      modulus: 11,
+    });
+
+    if (sum !== 0) {
+      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/no/orgnr.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './orgnr';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('no/orgnr', () => {
+  it('format:988077917', () => {
+    const result = format('988077917');
+
+    expect(result).toEqual('988 077 917');
+  });
+
+  it('validate:988 077 917', () => {
+    const result = validate('988 077 917');
+
+    expect(result.isValid && result.compact).toEqual('988077917');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:988 077 918', () => {
+    const result = validate('988 077 918');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/no/orgnr.ts

@@ -0,0 +1,75 @@
+/**
+ * Orgnr (Organisasjonsnummer, Norwegian organisation number).
+ *
+ * The Organisasjonsnummer is a 9-digit number with a straightforward check
+ * mechanism.
+ *
+ * Source
+ *   https://nn.wikipedia.org/wiki/Organisasjonsnummer
+ *   https://no.wikipedia.org/wiki/Organisasjonsnummer
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -/');
+}
+
+const impl: Validator = {
+  name: 'Norwegian Organization Number',
+  localName: 'Organisasjonsnummer',
+  abbreviation: 'Orgnr',
+
+  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() };
+    }
+
+    const sum = weightedSum(value, {
+      weights: [3, 2, 7, 6, 5, 4, 3, 2, 1],
+      modulus: 11,
+    });
+
+    if (sum !== 0) {
+      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/nz/bank.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './bank';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('nz/bank', () => {
+  it('format:01-902-0068389-00', () => {
+    const result = format('01-902-0068389-00');
+
+    expect(result).toEqual('01-0902-0068389-000');
+  });
+
+  it('validate:01-902-0068389-00', () => {
+    const result = validate('01-902-0068389-00');
+
+    expect(result.isValid && result.compact).toEqual('0109020068389000');
+  });
+
+  it('validate:123478', () => {
+    const result = validate('123478');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:01-902-0068388-00', () => {
+    const result = validate('01-902-0068388-00');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});