stdnum 1.10.0 → 1.10.1

package/src/de/svnr.ts

@@ -0,0 +1,158 @@
+/**
+ * SVNR or RVNR (Sozialversicherungsnummer, German social security / pension insurance number).
+ *
+ * The SVNR (or RVNR) is the German social security / pension insurance number.
+ * It's also called a social insuarance number. The number consists of 12 digits.
+ *
+ * Source
+ *   https://de.wikipedia.org/wiki/Versicherungsnummer
+ *   https://allaboutberlin.com/guides/german-versicherungsnummer
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { weightedSum } from '../util/checksum';
+import { Validator, ValidateReturn } from '../types';
+
+const AREA_NUMBER_OPTIONS = [
+  '02',
+  '03',
+  '04',
+  '08',
+  '09',
+  '10',
+  '11',
+  '12',
+  '13',
+  '14',
+  '15',
+  '16',
+  '17',
+  '18',
+  '19',
+  '20',
+  '21',
+  '23',
+  '24',
+  '25',
+  '26',
+  '28',
+  '29',
+  '38',
+  '39',
+  '40',
+  '80',
+  '81',
+  '82',
+  '89',
+].concat([...Array(79 - 42 + 1).keys()].map(x => (x + 42).toString())); // '42'-'79'
+
+const BIRTH_MONTH_OPTIONS = [
+  '01',
+  '02',
+  '03',
+  '04',
+  '05',
+  '06',
+  '07',
+  '08',
+  '09',
+  '10',
+  '11',
+  '12',
+];
+
+const checkAlphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const checkAlphabetDict: Record<string, number> = checkAlphabet
+  .split('')
+  .reduce(
+    (acc, c, idx) => ({
+      ...acc,
+      [c]: String(idx + 1).padStart(2, '0'),
+    }),
+    {},
+  );
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -./,');
+}
+
+const impl: Validator = {
+  name: 'German Pension Insurance Number',
+  localName: 'Sozialversicherungsnummer',
+  abbreviation: 'SVNR',
+  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, 8, 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.isalphanumeric(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!AREA_NUMBER_OPTIONS.includes(value.substring(0, 2))) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!strings.isdigits(value.substring(2, 4))) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!BIRTH_MONTH_OPTIONS.includes(value.substring(4, 6))) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!strings.isdigits(value.substring(6, 8))) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!strings.isalpha(value[8])) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!strings.isdigits(value.substring(9, 11))) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [frontWithAlpha, check] = strings.splitAt(value, 11);
+    const front = frontWithAlpha
+      .split('')
+      .map(c => checkAlphabetDict[c] ?? c)
+      .join('');
+    const sum = weightedSum(front, {
+      weights: [2, 1, 2, 5, 7, 1, 2, 1, 2, 1, 2, 1],
+      modulus: 10,
+      sumByDigit: true,
+    });
+
+    if (String(sum % 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/de/vat.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './vat';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('de/vat', () => {
+  it('format:DE 136,695 976', () => {
+    const result = format('DE 136,695 976');
+
+    expect(result).toEqual('136695976');
+  });
+
+  it('validate:DE136695976', () => {
+    const result = validate('DE136695976');
+
+    expect(result.isValid && result.compact).toEqual('136695976');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:136695978', () => {
+    const result = validate('136695978');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/de/vat.ts

@@ -0,0 +1,74 @@
+/**
+ * Ust ID Nr. (Umsatzsteuer Identifikationsnummer, German VAT number).
+ *
+ * The number is 10 digits long and uses the ISO 7064 Mod 11, 10 check digit
+ * algorithm.
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { iso7064mod10x11validate } from '../util/iso7064';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' -./,');
+  if (err !== null) {
+    return [value, err];
+  }
+  if (value.startsWith('DE')) {
+    return [value.substr(2), null];
+  }
+
+  return [value, null];
+}
+
+const impl: Validator = {
+  name: 'German VAT Number',
+  localName: 'Umsatzsteuer Identifikationsnummer',
+  abbreviation: 'USt ID 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 value;
+  },
+
+  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 (!iso7064mod10x11validate(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/dk/cpr.spec.ts

@@ -0,0 +1,34 @@
+import { InvalidComponent } from '../exceptions';
+import { format, getBirthDate, validate } from './cpr';
+
+describe('dk/cpr', () => {
+  it('format:2110625629', () => {
+    const result = format('2110625629');
+
+    expect(result).toEqual('211062-5629');
+  });
+
+  it('getBirthDate("511062-0629")', () => {
+    expect(() => {
+      getBirthDate('511062-0629');
+    }).toThrow(InvalidComponent);
+  });
+
+  it('getBirthDate("010180-1234")', () => {
+    const result = validate('010180-1234');
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate wrong date', () => {
+    const result = validate('511062-5629');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate future date', () => {
+    const result = validate('2110525629');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});

package/src/dk/cpr.ts

@@ -0,0 +1,129 @@
+/**
+ * CPR (personnummer, the Danish citizen number).
+ *
+ * The CPR is the national number to identify Danish citizens and is stored in
+ * the Det Centrale Personregister (Civil Registration System). The number
+ * consists of 10 digits in the format DDMMYY-SSSS where the first part
+ * represents the birth date and the second a sequence number. The first digit
+ * of the sequence number indicates the century.
+ *
+ * The numbers used to validate using a checksum but since the sequence numbers
+ * ran out this was abandoned in 2007. It is also not possible to use the
+ * checksum only for numbers that have a birth date before that because the
+ * numbers are also assigned to immigrants.
+ *
+ * More information:
+ *
+ * https://en.wikipedia.org/wiki/Personal_identification_number_(Denmark)
+ * https://da.wikipedia.org/wiki/CPR-nummer
+ * https://cpr.dk/
+ */
+
+import * as exceptions from '../exceptions';
+import { isValidDate, buildDate, validBirthdate, strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+export function getBirthDate(value: string): Date {
+  const [dob] = strings.splitAt(value, 6);
+  const [day, month, yearStr] = strings.splitAt(dob, 2, 4);
+
+  let year = parseInt(yearStr);
+
+  if ('5678'.includes(value[6]) && year >= 58) {
+    year += 1800;
+  } else if (
+    '0123'.includes(value[6]) ||
+    ('49'.includes(value[6]) && year >= 37)
+  ) {
+    year += 1900;
+  } else {
+    year += 2000;
+  }
+
+  const d = buildDate(String(year), month, day);
+
+  if (d === null || !isValidDate(String(year), month, day)) {
+    throw new exceptions.InvalidComponent(
+      'The number does not contain valid birth date information.',
+    );
+  }
+
+  return d;
+}
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' -');
+  if (err !== null) {
+    return [value, err];
+  }
+
+  return [value, null];
+}
+
+const impl: Validator = {
+  name: 'Danish Citizen Number',
+  localName: 'Personnummer',
+  abbreviation: 'CPR',
+  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 (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (value.length !== 10) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    try {
+      const date = getBirthDate(value);
+      if (!validBirthdate(date)) {
+        return {
+          isValid: false,
+          error: new exceptions.InvalidComponent(
+            'The birth date information is valid, but this person has not been born yet.',
+          ),
+        };
+      }
+    } catch (err) {
+      if (err instanceof exceptions.ValidationError) {
+        return {
+          isValid: false,
+          error: err,
+        };
+      }
+      return {
+        isValid: false,
+        error: new exceptions.InvalidComponent(String(err)),
+      };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/dk/cvr.spec.ts

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

package/src/dk/cvr.ts

@@ -0,0 +1,81 @@
+/**
+ * CVR (Momsregistreringsnummer, Danish VAT number).
+ *
+ * The CVR (Momsregistreringsnummer, VAT) is an 8 digit number with a
+ * straightforward check mechanism
+ *
+ * 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> {
+  const [value, err] = strings.cleanUnicode(input, ' -');
+  if (err !== null) {
+    return [value, err];
+  }
+  if (value.startsWith('DK')) {
+    return [value.substr(2), null];
+  }
+
+  return [value, null];
+}
+
+const impl: Validator = {
+  name: 'Danish VAT Number',
+  localName: 'Momsregistreringsnummer',
+  abbreviation: 'CVR',
+
+  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 !== 8) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, check] = strings.splitAt(value, -1);
+
+    const sum = weightedSum(front, {
+      modulus: 11,
+      weights: [2, 7, 6, 5, 4, 3, 2, 1],
+    });
+    if (String((11 - sum) % 10) !== 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/dk/index.ts

@@ -0,0 +1,2 @@
+export * as cpr from './cpr';
+export * as cvr from './cvr';

package/src/do/cedula.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './cedula';
+import { InvalidLength, InvalidFormat, InvalidChecksum } from '../exceptions';
+
+describe('do/cedula', () => {
+  it('format:00113918205', () => {
+    const result = format('00113918205');
+
+    expect(result).toEqual('001-1391820-5');
+  });
+
+  it('validate:00113918205', () => {
+    const result = validate('00113918205');
+
+    expect(result.isValid && result.compact).toEqual('00113918205');
+  });
+
+  it('validate:0011391820Q', () => {
+    const result = validate('0011391820Q');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:001139182', () => {
+    const result = validate('001139182');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:00113918204', () => {
+    const result = validate('00113918204');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/do/cedula.ts

@@ -0,0 +1,67 @@
+/**
+ * Cedula (Dominican Republic national identification number).
+ *
+ * A cedula is is an 11-digit number issues by the Dominican Republic government
+ * to citizens or residents for identification purposes.
+ *
+ * Source
+ *
+ * VAT PERSON
+ */
+
+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: 'Dominican Republic National Identification Number',
+  localName: 'Cedula',
+  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, 10).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.substr(1))) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (!luhnChecksumValidate(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;

package/src/do/index.ts

@@ -0,0 +1,3 @@
+export * as cedula from './cedula';
+export * as ncf from './ncf';
+export * as rnc from './rnc';

package/src/do/ncf.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './ncf';
+import { InvalidLength, InvalidComponent } from '../exceptions';
+
+describe('do/ncf', () => {
+  it('format:E31 000000 0005', () => {
+    const result = format('E31 000000 0005');
+
+    expect(result).toEqual('E310000000005');
+  });
+
+  it('validate:E310000000005', () => {
+    const result = validate('E310000000005');
+
+    expect(result.isValid && result.compact).toEqual('E310000000005');
+  });
+
+  it('validate:B0100000005', () => {
+    const result = validate('B0100000005');
+
+    expect(result.isValid && result.compact).toEqual('B0100000005');
+  });
+
+  it('validate:Z0100000005', () => {
+    const result = validate('Z0100000005');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:Z0100', () => {
+    const result = validate('Z0100');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+});