stdnum 1.10.0 → 1.10.1

package/src/be/personIdentifierHelpers.spec.ts

@@ -0,0 +1,254 @@
+import {
+  validStructure,
+  validChecksum,
+  toDateArray,
+} from './personIdentifierHelpers';
+
+describe('personIdentifierHelpers', () => {
+  const toDob = (string: string): string => {
+    const [y, m, d] = toDateArray(string).map(s => parseInt(s, 10));
+    return [y, m - 1, d].map(n => `${n}`.padStart(2, '0')).join('');
+  };
+
+  describe('validStructure', () => {
+    describe('default dob conversion', () => {
+      it('returns true for a valid 20th century date', () => {
+        expect(validStructure('99012599999')).toEqual(true);
+      });
+
+      it('returns true for a potential 21st century date', () => {
+        expect(validStructure('01012599999')).toEqual(true);
+      });
+
+      it('returns true for an unknown date of birth', () => {
+        expect(validStructure('01009999999')).toEqual(true);
+      });
+
+      it('returns false for a string that is neither an unknown date of birth or a valid date of birth', () => {
+        expect(validStructure('99999999999')).toEqual(false);
+      });
+    });
+
+    describe('specified dob conversion', () => {
+      it('returns true for a valid 20th century date', () => {
+        expect(validStructure('991331999999', toDob)).toEqual(true);
+      });
+
+      it('returns true for a potential 21st century date', () => {
+        expect(validStructure('011331999999', toDob)).toEqual(true);
+      });
+
+      it('returns true for an unknown date of birth', () => {
+        expect(validStructure('990199999999', toDob)).toEqual(true);
+      });
+
+      it('returns false for a string that is neither an unknown date of birth or a valid date of birth', () => {
+        expect(validStructure('99999999999', toDob)).toEqual(false);
+      });
+    });
+  });
+
+  describe('validChecksum', () => {
+    const range = Array.from({ length: 100 }, (_, n) => n);
+
+    describe('default dob conversion', () => {
+      describe('a date of birth valid in the 20th century only', () => {
+        const baseString = '990430999';
+        const checksum = 14;
+
+        it('returns true when the checksum is valid', () => {
+          const string = `${baseString}${checksum}`;
+          expect(validChecksum(string)).toEqual(true);
+        });
+
+        it('returns false when the checksum is invalid', () => {
+          const toCheck = range.filter(x => x !== checksum);
+          toCheck.forEach(cs => {
+            const string = `${baseString}${cs}`;
+            expect(validChecksum(string)).toEqual(false);
+          });
+        });
+      });
+
+      describe('a date of birth valid in the 21st century only', () => {
+        const baseString = '000229999'; // 1900 was not a leap year
+        const checksum = 17;
+
+        it('returns true when the checksum is valid', () => {
+          const string = `${baseString}${checksum}`;
+          expect(validChecksum(string)).toEqual(true);
+        });
+
+        it('returns false when the checksum is invalid', () => {
+          const toCheck = range.filter(x => x !== checksum);
+          toCheck.forEach(cs => {
+            const string = `${baseString}${cs}`;
+            expect(validChecksum(string)).toEqual(false);
+          });
+        });
+      });
+
+      describe('a date of birth valid in either the 20th or 21st century', () => {
+        const baseString = '100430999';
+        const twentiethCenturyChecksum = 85;
+        const twentyfirstCenturyChecksum = 17;
+
+        it('returns true when the checksum is valid for the 20th century', () => {
+          const string = `${baseString}${twentiethCenturyChecksum}`;
+          expect(validChecksum(string)).toEqual(true);
+        });
+
+        it('returns true when the checksum is valid for the 21th century', () => {
+          const string = `${baseString}${twentyfirstCenturyChecksum}`;
+          expect(validChecksum(string)).toEqual(true);
+        });
+
+        it('returns false when the checksum is invalid', () => {
+          const excludedChecksums = [
+            twentiethCenturyChecksum,
+            twentyfirstCenturyChecksum,
+          ];
+          const toCheck = range.filter(x => !excludedChecksums.includes(x));
+          toCheck.forEach(cs => {
+            const string = `${baseString}${cs}`;
+            expect(validChecksum(string)).toEqual(false);
+          });
+        });
+      });
+
+      describe('an unknown date of birth', () => {
+        const baseString = '100001999';
+        const twentiethCenturyChecksum = 54;
+        const twentyfirstCenturyChecksum = 83;
+
+        it('returns true when the checksum is valid for the 20th century', () => {
+          const string = `${baseString}${twentiethCenturyChecksum}`;
+          expect(validChecksum(string)).toEqual(true);
+        });
+
+        it('returns true when the checksum is valid for the 21th century', () => {
+          const string = `${baseString}${twentyfirstCenturyChecksum}`;
+          expect(validChecksum(string)).toEqual(true);
+        });
+
+        it('returns false when the checksum is invalid', () => {
+          const excludedChecksums = [
+            twentiethCenturyChecksum,
+            twentyfirstCenturyChecksum,
+          ];
+          const toCheck = range.filter(x => !excludedChecksums.includes(x));
+          toCheck.forEach(cs => {
+            const string = `${baseString}${cs}`;
+            expect(validChecksum(string)).toEqual(false);
+          });
+        });
+      });
+    });
+
+    describe('specified dob conversion', () => {
+      describe('a date of birth valid in the 20th century only', () => {
+        const baseString = '990631999';
+        const checksum = 95;
+
+        it('returns true when the checksum is valid', () => {
+          const string = `${baseString}${checksum}`;
+          expect(validChecksum(string, toDob)).toEqual(true);
+        });
+
+        it('returns false when the checksum is invalid', () => {
+          const toCheck = range.filter(x => x !== checksum);
+          toCheck.forEach(cs => {
+            const string = `${baseString}${cs}`;
+            expect(validChecksum(string, toDob)).toEqual(false);
+          });
+        });
+      });
+
+      describe('a date of birth valid in the 21st century only', () => {
+        const baseString = '000329999'; // 1900 was not a leap year
+        const checksum = 24;
+
+        it('returns true when the checksum is valid', () => {
+          const string = `${baseString}${checksum}`;
+          expect(validChecksum(string, toDob)).toEqual(true);
+        });
+
+        it('returns false when the checksum is invalid', () => {
+          const toCheck = range.filter(x => x !== checksum);
+          toCheck.forEach(cs => {
+            const string = `${baseString}${cs}`;
+            expect(validChecksum(string, toDob)).toEqual(false);
+          });
+        });
+      });
+
+      describe('a date of birth valid in either the 20th or 21st century', () => {
+        const baseString = '100430999';
+        const twentiethCenturyChecksum = 85;
+        const twentyfirstCenturyChecksum = 17;
+
+        it('returns true when the checksum is valid for the 20th century', () => {
+          const string = `${baseString}${twentiethCenturyChecksum}`;
+          expect(validChecksum(string, toDob)).toEqual(true);
+        });
+
+        it('returns true when the checksum is valid for the 21th century', () => {
+          const string = `${baseString}${twentyfirstCenturyChecksum}`;
+          expect(validChecksum(string, toDob)).toEqual(true);
+        });
+
+        it('returns false when the checksum is invalid', () => {
+          const excludedChecksums = [
+            twentiethCenturyChecksum,
+            twentyfirstCenturyChecksum,
+          ];
+          const toCheck = range.filter(x => !excludedChecksums.includes(x));
+          toCheck.forEach(cs => {
+            const string = `${baseString}${cs}`;
+            expect(validChecksum(string, toDob)).toEqual(false);
+          });
+        });
+      });
+
+      describe('an unknown date of birth', () => {
+        const baseString = '100101999';
+        const twentiethCenturyChecksum = 61;
+        const twentyfirstCenturyChecksum = 90;
+
+        it('returns true when the checksum is valid for the 20th century', () => {
+          const string = `${baseString}${twentiethCenturyChecksum}`;
+          expect(validChecksum(string, toDob)).toEqual(true);
+        });
+
+        it('returns true when the checksum is valid for the 21th century', () => {
+          const string = `${baseString}${twentyfirstCenturyChecksum}`;
+          expect(validChecksum(string, toDob)).toEqual(true);
+        });
+
+        it('returns false when the checksum is invalid', () => {
+          const excludedChecksums = [
+            twentiethCenturyChecksum,
+            twentyfirstCenturyChecksum,
+          ];
+          const toCheck = range.filter(x => !excludedChecksums.includes(x));
+          toCheck.forEach(cs => {
+            const string = `${baseString}${cs}`;
+            expect(validChecksum(string, toDob)).toEqual(false);
+          });
+        });
+      });
+    });
+  });
+
+  describe('toDateArray', () => {
+    it('works with a string of length 6', () => {
+      const string = '013150';
+      expect(toDateArray(string)).toEqual(['01', '31', '50']);
+    });
+
+    it('works with a string of length greater than 6', () => {
+      const string = '013150999';
+      expect(toDateArray(string)).toEqual(['01', '31', '50']);
+    });
+  });
+});

package/src/be/personIdentifierHelpers.ts

@@ -0,0 +1,130 @@
+import { strings, isValidDateCompactYYYYMMDD } from '../util';
+
+function getApproximatelyNow() {
+  const ONE_DAY = 1000 * 60 * 60 * 24;
+  return new Date(Date.now() + ONE_DAY);
+}
+
+function isInPast(date: string | number): boolean {
+  return new Date(String(date)) <= getApproximatelyNow();
+}
+
+function getFullYears(yy: string | number): number[] {
+  const yval = typeof yy === 'string' ? parseInt(yy, 10) : yy;
+
+  return [1900 + yval, 2000 + yval];
+}
+
+function getFirstSix(number: string): string {
+  return strings.splitAt(number, 6)[0];
+}
+
+function getBaseNumber(number: string): string {
+  return strings.splitAt(number, 9)[0];
+}
+
+function getChecksum(number: string): number {
+  const checksumString = strings.splitAt(number, 9)[1];
+  return parseInt(checksumString, 10);
+}
+
+export function toDateArray(number: string): string[] {
+  const [yy, mm, dd] = strings.splitAt(number, 2, 4, 6);
+
+  return [yy, mm, dd];
+}
+
+function getValidPastDates(yymmdd: string): Array<string> {
+  const [yy, mm, dd] = toDateArray(yymmdd);
+
+  return getFullYears(yy)
+    .filter(yyyy => isValidDateCompactYYYYMMDD(`${yyyy}${mm}${dd}`))
+    .map(yyyy => `${yyyy}-${mm}-${dd}`)
+    .filter(isInPast);
+}
+
+function isUnknownDob(dob: string): boolean {
+  if (['000001', '002001', '004001'].includes(dob)) {
+    return true;
+  }
+
+  const [yy, mm, dd] = toDateArray(dob);
+
+  return strings.isdigits(yy) && mm === '00' && strings.isdigits(dd);
+}
+
+function toChecksumBasis(year: number, baseNumber: string): number {
+  return parseInt(year < 2000 ? baseNumber : `${2}${baseNumber}`, 10);
+}
+
+function isValidDob(dob: string): boolean {
+  return Boolean(getValidPastDates(dob).length);
+}
+
+function defaultToDob(origFirstSix: string): string {
+  return origFirstSix;
+}
+
+function isValidFirstSix(
+  firstSix: string,
+  toDob: typeof defaultToDob,
+): boolean {
+  const dob = toDob(firstSix);
+  return isUnknownDob(dob) || isValidDob(dob);
+}
+
+export function validStructure(
+  number: string,
+  toDob: typeof defaultToDob = defaultToDob,
+): boolean {
+  const firstSix = getFirstSix(number);
+  return isValidFirstSix(firstSix, toDob);
+}
+
+function getChecksumBasesUnknownDob(baseNumber: string): Array<number> {
+  const firstSix = getFirstSix(baseNumber);
+  const [yy] = toDateArray(firstSix);
+
+  return getFullYears(yy)
+    .filter(isInPast)
+    .map(year => toChecksumBasis(year, baseNumber));
+}
+
+function getChecksumBasesForStandardDob(
+  baseNumber: string,
+  toDob: typeof defaultToDob,
+): Array<number> {
+  const firstSix = getFirstSix(baseNumber);
+  const dob = toDob(firstSix);
+  const validPastDates = getValidPastDates(dob);
+  const extractYearFromDate = (date: string): number =>
+    parseInt(date.split('-')[0], 10);
+  const validPastYears = validPastDates.map(extractYearFromDate);
+  return validPastYears.map(year => toChecksumBasis(year, baseNumber));
+}
+
+function getChecksumBases(
+  number: string,
+  toDob: typeof defaultToDob,
+): Array<number> {
+  const firstSix = getFirstSix(number);
+  const dob = toDob(firstSix);
+  const baseNumber = getBaseNumber(number);
+
+  if (isUnknownDob(dob)) return getChecksumBasesUnknownDob(baseNumber);
+
+  return getChecksumBasesForStandardDob(baseNumber, toDob);
+}
+
+function isValidChecksumPair(checksumBasis: number, checksum: number): boolean {
+  return !((checksumBasis + checksum) % 97);
+}
+
+export function validChecksum(
+  number: string,
+  toDob: typeof defaultToDob = defaultToDob,
+): boolean {
+  const checksumBases = getChecksumBases(number, toDob);
+  const checksum = getChecksum(number);
+  return checksumBases.some(csb => isValidChecksumPair(csb, checksum));
+}

package/src/be/vat.spec.ts

@@ -0,0 +1,46 @@
+import { validate, format } from './vat';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('be/vat', () => {
+  it('format:403019261', () => {
+    const result = format('403019261');
+
+    expect(result).toEqual('0403019261');
+  });
+
+  it('validate:BE403019261', () => {
+    const result = validate('BE403019261');
+
+    expect(result.isValid && result.compact).toEqual('0403019261');
+  });
+
+  it('validate:(0)403019261', () => {
+    const result = validate('(0)403019261');
+
+    expect(result.isValid && result.compact).toEqual('0403019261');
+  });
+
+  it('validate:BE 428759497', () => {
+    const result = validate('BE 428759497');
+
+    expect(result.isValid && result.compact).toEqual('0428759497');
+  });
+
+  it('validate:BE 0417497106', () => {
+    const result = validate('BE 0417497106');
+
+    expect(result.isValid && result.compact).toEqual('0417497106');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:BE431150351', () => {
+    const result = validate('BE431150351');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/be/vat.ts

@@ -0,0 +1,84 @@
+/**
+ * BTW, TVA, NWSt, ondernemingsnummer (Belgian enterprise number).
+ *
+ * The enterprise number (ondernemingsnummer) is a unique identifier of
+ * companies within the Belgian administrative services. It was previously
+ * the VAT ID number. The number consists of 10 digits.
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  // eslint-disable-next-line prefer-const
+  let [value, err] = strings.cleanUnicode(input, ' -.');
+
+  if (err !== null) {
+    return [value, err];
+  }
+  if (value.startsWith('BE')) {
+    value = value.substr(2);
+  }
+  if (value.startsWith('(0)')) {
+    value = `0${value.substr(3)}`;
+  }
+  if (value.length === 9) {
+    value = `0${value}`;
+  }
+
+  return [value, null];
+}
+
+const impl: Validator = {
+  name: 'Belgian VAT Number',
+  localName: 'Ondernemingsnummer',
+  abbreviation: 'BTW, NWSt',
+  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 !== 10) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, sum] = strings.splitAt(value, -2);
+
+    if (97 - (parseInt(front, 10) % 97) !== parseInt(sum, 10)) {
+      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/bg/egn.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './egn';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('bg/egn', () => {
+  it('format:752316 926 3', () => {
+    const result = format('752316 926 3');
+
+    expect(result).toEqual('7523169263');
+  });
+
+  it('validate:8032056031', () => {
+    const result = validate('8032056031');
+
+    expect(result.isValid && result.compact).toEqual('8032056031');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:8032056032', () => {
+    const result = validate('8032056032');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/bg/egn.ts

@@ -0,0 +1,75 @@
+/**
+ * EGN (ЕГН, Единен граждански номер, Bulgarian personal identity codes).
+ *
+ * It is a 10-digit number of which the first 6 digits denote the person's
+ * birth date, the next three digits represent a birth order number from
+ * which the person's gender can be determined and the last digit is a check
+ * digit.
+ *
+ * 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: 'Bulgarian Personal Identity Codes',
+  localName: 'Единен граждански номер',
+  abbreviation: 'ЕГН (EGN)',
+  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 !== 10) {
+      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, 4, 8, 5, 10, 9, 7, 3, 6],
+    });
+
+    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/bg/index.ts

@@ -0,0 +1,3 @@
+export * as egn from './egn';
+export * as pnf from './pnf';
+export * as vat from './vat';

package/src/bg/pnf.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './pnf';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('bg/pnf', () => {
+  it('format:7111 042 925', () => {
+    const result = format('7111 042 925');
+
+    expect(result).toEqual('7111042925');
+  });
+
+  it('validate:7111 042 925', () => {
+    const result = validate('7111 042 925');
+
+    expect(result.isValid && result.compact).toEqual('7111042925');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:7111 042 926', () => {
+    const result = validate('7111 042 926');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});