stdnum 1.10.0 → 1.10.1

package/src/us/ssn.ts

@@ -0,0 +1,117 @@
+/**
+ * SSN (U.S. Social Security Number).
+ *
+ * The Social Security Number is used to identify individuals for taxation
+ * purposes. It is a 9-digit number that consists of a 3-digit area number, a
+ * 2-digit group number and a 4-digit serial number. The number does not use a
+ * check digit.
+ *
+ * Sources:
+ *    https://en.wikipedia.org/wiki/Social_Security_number
+ *    https://www.ssa.gov/employer/verifySSN.htm
+ *
+ * INDIVIDUAL
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+const invalidSSN = [
+  '111111111',
+  '222222222',
+  '333333333',
+  '444444444',
+  '555555555',
+  '777777777',
+  '888888888',
+  '999999999',
+  '123123123',
+  '999999999',
+  // Used in Advertising and known "invalid"
+  '002281852',
+  '042103580',
+  '062360749',
+  '078051120',
+  '095073645',
+  '128036045',
+  '135016629',
+  '141186941',
+  '165167999',
+  '165187999',
+  '165207999',
+  '165227999',
+  '165247999',
+  '189092294',
+  '212097694',
+  '212099999',
+  '219099999',
+  '306302348',
+  '308125070',
+  '457555462',
+  '468288779',
+  '549241889',
+];
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, '- ');
+}
+
+const impl: Validator = {
+  name: 'U.S. Social Security Number',
+  localName: 'Social Security Number',
+  abbreviation: 'SSN',
+  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, 5).join('-');
+  },
+
+  /**
+   * Check if the number is a valid SSN number.
+   * This checks the length, formatting and other contraints. It does not check
+   * for control letter.
+   */
+  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.InvalidComponent() };
+    }
+    if (invalidSSN.includes(value)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (/^(000|666|9)\d+/.test(value)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (/^\d{3}00\d{4}/.test(value)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/util/checksum.spec.ts

@@ -0,0 +1,70 @@
+import {
+  luhnChecksumDigit,
+  luhnChecksumValue,
+  mod11mod10Validate,
+  mod97base10Validate,
+} from './checksum';
+
+describe('util/checksum', () => {
+  describe('luhnChecksumValue', () => {
+    it('basic', () => {
+      expect(luhnChecksumValue('7894')).toEqual(6);
+    });
+  });
+
+  describe('luhnChecksumDigit', () => {
+    it.each([
+      ['7894', '9'],
+      ['8667046', '0'],
+    ])(
+      'luhnChecksumDigit %s should return %s',
+      (digits: string, expectedResult: string) => {
+        expect(luhnChecksumDigit(digits)).toEqual(expectedResult);
+      },
+    );
+  });
+
+  describe('mod97base10Validate', () => {
+    test.each(['9999123456789012141490', '08686001256515001121751'])(
+      'value:%s',
+      value => {
+        expect(mod97base10Validate(value)).toBe(true);
+      },
+    );
+  });
+
+  describe('mod11mod10Validate', () => {
+    test.each([
+      '07945',
+      '794623',
+      '002006673085',
+      '65112243004304827',
+      '532668787803570012647762156873137851288684',
+      '0032',
+      '78463064456075552581616161662',
+      '8615430533535456311886713716284873171332581774130',
+      '45557738808',
+      '710652041271831466162726767146582126527534',
+      '47166',
+      '680584514238577341080173637733642828500321',
+      '46746786646531',
+      '423280260',
+      '5003002243435846626846005060042255674451267241175',
+      '654280720481568053641275304858644021632559',
+      '3086551843863',
+      '43177541563430485407585286786376851344',
+      '46000342367741',
+      '13858121045117455586725505241387248109',
+      '15631047568645066248754360824525460366184664246',
+      '716606185585077454311714605',
+      '36760125602740581257256826035731224471746311354',
+      '8537',
+    ])('validate:%s', value => {
+      expect(mod11mod10Validate(value)).toBe(true);
+    });
+
+    test.each(['17945', '17944'])('invalid:%s', value => {
+      expect(mod11mod10Validate(value)).toBe(false);
+    });
+  });
+});

package/src/util/checksum.ts

@@ -0,0 +1,258 @@
+/**
+ * From stack overflow
+ * - Add all digits of a given number
+ * - https://stackoverflow.com/questions/38334652/sum-all-the-digits-of-a-number-javascript
+ */
+function sumAllDigits(value: number) {
+  let localValue = value;
+  let sum = 0;
+
+  while (localValue) {
+    sum += localValue % 10;
+    localValue = Math.floor(localValue / 10);
+  }
+
+  return sum;
+}
+
+/**
+ * Compute the weighted sum of a string
+ * @param {boolean} sumByDigit - ex) if checksum entry is 18, add 9 (sum of digits) to the sum (instead of 18).
+ */
+export function weightedSum(
+  value: string,
+  {
+    alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+    reverse = false,
+    weights = [1],
+    modulus = 0,
+    sumByDigit = false,
+  }: {
+    alphabet?: string;
+    reverse?: boolean;
+    modulus: number;
+    weights?: number[];
+    sumByDigit?: boolean;
+  },
+): number {
+  const wlen = weights.length;
+  const numbers = value.split('').map(v => alphabet.indexOf(v));
+  const weighted = (reverse ? numbers.reverse() : numbers).map(
+    (v, idx) => v * weights[idx % wlen],
+  );
+
+  return weighted.reduce((acc, v) => {
+    let vv = v;
+    while (vv < 0) {
+      vv += modulus;
+    }
+
+    if (sumByDigit && vv > 9) {
+      return (acc + sumAllDigits(vv)) % modulus;
+    }
+
+    return (acc + vv) % modulus;
+  }, 0);
+}
+
+export function luhnChecksum(value: string, alphabet = '0123456789'): number {
+  const parity = value.length % 2;
+
+  const sum = value
+    .split('')
+    .reverse()
+    .map(v => alphabet.indexOf(v))
+    .reduce((acc, val, idx) => {
+      const v = idx % 2 === parity ? val * 2 : val;
+
+      return acc + (v > 9 ? v - 9 : v);
+    }, 0);
+
+  // return sum % 10 === 0;
+  return sum % alphabet.length;
+}
+
+export function luhnChecksumValidate(
+  value: string,
+  alphabet = '0123456789',
+): boolean {
+  const parity = value.length % 2;
+
+  const sum = value
+    .split('')
+    // .reverse()
+    .map(v => alphabet.indexOf(v))
+    .reduce((acc, val, idx) => {
+      let v = val;
+      if (idx % 2 === parity) {
+        v = val * 2;
+        if (v > 9) {
+          v -= 9;
+        }
+      }
+
+      return acc + v;
+    }, 0);
+
+  return sum % 10 === 0;
+}
+
+/**
+ * Compute the Luhn checksum over the provider number.  The checksum is returned as
+ * a Number.  Valid numbers should be equal to 0
+ */
+export function luhnChecksumValue(
+  value: string,
+  alphabet = '0123456789',
+): number {
+  const alen = alphabet.length;
+
+  return value
+    .split('')
+    .reverse()
+    .map(v => alphabet.indexOf(v))
+    .reduce((acc, v, idx) => {
+      if (idx % 2 === 0) {
+        return (acc + v) % alen;
+      }
+
+      return (acc + Math.floor((v * 2) / alen) + ((v * 2) % alen)) % alen;
+    });
+}
+
+/**
+ * Compute the checksum digit that should be provided given the alphabet
+ *   (e.g. calc_check_digit)
+ */
+export function luhnChecksumDigit(
+  value: string,
+  alphabet = '0123456789',
+): string {
+  const cs = luhnChecksumValue(`${value}${alphabet[0]}`);
+
+  return alphabet[(alphabet.length - cs) % alphabet.length];
+}
+
+/*
+For more info on the algorithm: http://en.wikipedia.org/wiki/Verhoeff_algorithm
+by Sergey Petushkov, 2014
+*/
+
+// multiplication table d
+const verhoeffD = [
+  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+  [1, 2, 3, 4, 0, 6, 7, 8, 9, 5],
+  [2, 3, 4, 0, 1, 7, 8, 9, 5, 6],
+  [3, 4, 0, 1, 2, 8, 9, 5, 6, 7],
+  [4, 0, 1, 2, 3, 9, 5, 6, 7, 8],
+  [5, 9, 8, 7, 6, 0, 4, 3, 2, 1],
+  [6, 5, 9, 8, 7, 1, 0, 4, 3, 2],
+  [7, 6, 5, 9, 8, 2, 1, 0, 4, 3],
+  [8, 7, 6, 5, 9, 3, 2, 1, 0, 4],
+  [9, 8, 7, 6, 5, 4, 3, 2, 1, 0],
+];
+
+// permutation table p
+const verhoeffP = [
+  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+  [1, 5, 7, 6, 2, 8, 3, 0, 9, 4],
+  [5, 8, 0, 3, 7, 9, 6, 1, 4, 2],
+  [8, 9, 1, 6, 0, 4, 3, 5, 2, 7],
+  [9, 4, 5, 3, 1, 2, 6, 8, 7, 0],
+  [4, 2, 8, 6, 5, 7, 3, 9, 0, 1],
+  [2, 7, 9, 3, 8, 0, 6, 4, 1, 5],
+  [7, 0, 4, 6, 9, 1, 3, 2, 5, 8],
+];
+
+// inverse table inv
+const verhoeffInv = [0, 4, 3, 2, 1, 5, 6, 7, 8, 9];
+
+// converts string or number to an array and inverts it
+function invArray(array: string): number[] {
+  return array
+    .split('')
+    .map(v => parseInt(v, 10))
+    .reverse();
+}
+
+// generates checksum
+export function verhoeffGenerate(array: string): number {
+  const invertedArray = invArray(array);
+
+  const value = invertedArray.reduce(
+    (c, v, idx) => verhoeffD[c][verhoeffP[(idx + 1) % 8][v]],
+    0,
+  );
+
+  return verhoeffInv[value];
+}
+
+// validates checksum
+export function verhoeffValidate(array: string): boolean {
+  const invertedArray = invArray(array);
+
+  const sum = invertedArray.reduce(
+    (c, v, idx) => verhoeffD[c][verhoeffP[idx % 8][v]],
+    0,
+  );
+
+  return sum === 0;
+}
+
+// From stackover flow
+//   https://stackoverflow.com/questions/929910/modulo-in-javascript-large-number
+function modulo(dividentIn: string, divisor: number) {
+  let divident = dividentIn;
+  const partLength = 10;
+
+  while (divident.length > partLength) {
+    const part = divident.substring(0, partLength);
+    divident = (parseInt(part, 10) % divisor) + divident.substring(partLength);
+  }
+
+  return parseInt(divident, 10) % divisor;
+}
+
+/**
+ * The ISO 7064 Mod 97, 10 algorithm.
+ *
+ * The Mod 97, 10 algorithm evaluates the whole number as an integer which is
+ * valid if the number modulo 97 is 1. As such it has two check digits.
+ */
+export function mod97base10Validate(value: string, expect = 1): boolean {
+  const alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+  let fail = false;
+
+  const bigValue = value
+    .split('')
+    .map(c => {
+      const idx = alphabet.indexOf(c);
+      if (idx === -1) {
+        fail = true;
+        return '';
+      }
+      return String(idx);
+    })
+    .join('');
+
+  if (fail) {
+    return false;
+  }
+
+  return modulo(bigValue, 97) === expect;
+}
+
+/**
+ *  The ISO 7064 Mod 11, 10 algorithm.
+ *
+ * The Mod 11, 10 algorithm uses a number of calculations modulo 11 and 10 to
+ * determine a checksum.
+ */
+export function mod11mod10Validate(value: string): boolean {
+  const sum = value
+    .split('')
+    .map(v => parseInt(v, 10))
+    .reduce((acc, n) => ((((acc === 0 ? 10 : acc) * 2) % 11) + n) % 10, 5);
+
+  return sum === 1;
+}

package/src/util/index.ts

@@ -0,0 +1,13 @@
+import * as strings from './strings';
+
+export { weightedSum, mod97base10Validate } from './checksum';
+export {
+  buildDate,
+  validBirthdate,
+  isValidDate,
+  isValidDateCompactYYYYMMDD,
+  isValidDateCompactYYMMDD,
+  isValidDateCompactDDMMYY,
+} from './isValidDate';
+
+export { strings };

package/src/util/isValidDate.spec.ts

@@ -0,0 +1,49 @@
+import { isValidDate, validBirthdate } from './isValidDate';
+
+describe('isValidDate', () => {
+  it('2020-01-02', () => {
+    expect(isValidDate('2020', '01', '02')).toEqual(true);
+  });
+
+  it('2020-01-40', () => {
+    expect(isValidDate('2020', '01', '40')).toEqual(false);
+  });
+
+  it('19-02-29', () => {
+    expect(isValidDate('19', '02', '29')).toEqual(false);
+  });
+
+  it('20-02-29', () => {
+    expect(isValidDate('20', '02', '29')).toEqual(true);
+  });
+
+  describe('birthdates', () => {
+    describe('validBirthdate', () => {
+      it('today', () => {
+        const now = new Date();
+        // remove those pesky minutes...
+        const date = new Date(now.toISOString().substring(0, 10));
+        expect(validBirthdate(date)).toEqual(true);
+      });
+
+      it('tomorrow', () => {
+        const now = new Date();
+        now.setDate(now.getDate() + 1);
+        const date = new Date(now.toISOString().substring(0, 10));
+        expect(validBirthdate(date)).toEqual(false);
+      });
+
+      it('2010-01-01', () => {
+        expect(validBirthdate(new Date('2010-01-01'))).toEqual(true);
+      });
+
+      it('2030-01-01', () => {
+        expect(validBirthdate(new Date('2030-01-01'))).toEqual(false);
+      });
+    });
+
+    it('2090-02-29', () => {
+      expect(isValidDate('2090', '02', '29', true)).toEqual(false);
+    });
+  });
+});

package/src/util/isValidDate.ts

@@ -0,0 +1,87 @@
+import { splitAt } from './strings';
+
+export function validBirthdate(date: Date | null): boolean {
+  if (date === null) {
+    return false;
+  }
+
+  const now = new Date();
+  return date.getTime() <= now.getTime();
+}
+
+export function buildDate(yy: string, mm: string, dd: string): Date | null {
+  const yyN = parseInt(yy, 10);
+  const mmN = parseInt(mm, 10) - 1;
+  const ddN = parseInt(dd, 10);
+
+  if (Number.isNaN(yyN) || Number.isNaN(mmN) || Number.isNaN(ddN)) {
+    return null;
+  }
+
+  let d;
+  if (yyN < 20) {
+    d = new Date(2000 + yyN, mmN, ddN);
+  } else if (yyN < 100) {
+    d = new Date(1900 + yyN, mmN, ddN);
+  } else {
+    d = new Date(yyN, mmN, ddN);
+  }
+
+  if (Number.isNaN(d.getFullYear())) {
+    return null;
+  }
+
+  // Date will convert Jan 30 -> Feb 9, make sure this didn't happen
+  if (d.getDate() !== ddN || d.getMonth() !== mmN) {
+    return null;
+  }
+
+  return d;
+}
+
+/** Check to make sure this is a valid date
+ *  isBefore checks to make sure that the date is today or before, this
+ *  typically is used for birtdays (you could be born today)
+ */
+export function isValidDate(
+  yy: string,
+  mm: string,
+  dd: string,
+  isBefore = false,
+): boolean {
+  const d = buildDate(yy, mm, dd);
+
+  if (d === null) {
+    return false;
+  }
+
+  return isBefore ? validBirthdate(d) : true;
+}
+
+/** Check to make sure this is a valid date */
+export function isValidDateCompactYYMMDD(
+  yymmdd: string,
+  isBefore = false,
+): boolean {
+  const [year, mon, day] = splitAt(yymmdd, 2, 4);
+
+  return isValidDate(year, mon, day, isBefore);
+}
+
+export function isValidDateCompactDDMMYY(
+  ddmmyy: string,
+  isBefore = false,
+): boolean {
+  const [day, mon, year] = splitAt(ddmmyy, 2, 4);
+
+  return isValidDate(year, mon, day, isBefore);
+}
+
+export function isValidDateCompactYYYYMMDD(
+  yyyymmdd: string,
+  isBefore = false,
+): boolean {
+  const [year, mon, day] = splitAt(yyyymmdd, 4, 6);
+
+  return isValidDate(year, mon, day, isBefore);
+}

package/src/util/iso7064.spec.ts

@@ -0,0 +1,17 @@
+import { iso7064mod10x11validate } from './iso7064';
+
+describe('iso7064', () => {
+  describe('iso7064mod10x11validate', () => {
+    it('794623', () => {
+      expect(iso7064mod10x11validate('794623')).toEqual(true);
+    });
+
+    it('002006673085', () => {
+      expect(iso7064mod10x11validate('002006673085')).toEqual(true);
+    });
+
+    it('00200667308', () => {
+      expect(iso7064mod10x11validate('00200667308')).toEqual(false);
+    });
+  });
+});

package/src/util/iso7064.ts

@@ -0,0 +1,8 @@
+export function iso7064mod10x11validate(value: string): boolean {
+  const check = value
+    .split('')
+    .map(v => parseInt(v, 10))
+    .reduce((acc, v) => ((((acc === 0 ? 10 : acc) * 2) % 11) + v) % 10, 5);
+
+  return check === 1;
+}

package/src/util/pymod.ts

@@ -0,0 +1,8 @@
+///
+// Match pythons handling of negative modulus math  (e.g. -1 % 7 === 6)
+//
+//  https://stackoverflow.com/questions/41239190/result-of-17-is-different-in-javascript-1-and-python6
+//
+export function pymod(value: number, modulus: number): number {
+  return ((value % modulus) + modulus) % modulus;
+}

package/src/util/strings/char.ts

@@ -0,0 +1,18 @@
+const alphanumericRE = /^[A-Za-z0-9]+$/;
+const digitRE = /^[0-9]+$/;
+const alphaRE = /^[A-Za-z]+$/;
+
+/**
+ * Alpha numeric check A-Za-z0-9
+ */
+export function isalphanumeric(value: string): boolean {
+  return alphanumericRE.test(value);
+}
+
+export function isdigits(value: string): boolean {
+  return digitRE.test(value);
+}
+
+export function isalpha(value: string): boolean {
+  return alphaRE.test(value);
+}

package/src/util/strings/clean.spec.ts

@@ -0,0 +1,15 @@
+import { cleanUnicode } from './clean';
+
+describe('clean', () => {
+  it('basic', () => {
+    expect(cleanUnicode('123', '2')[0]).toEqual('13');
+  });
+
+  it('unicode-9', () => {
+    expect(cleanUnicode('\u{1D7FF}9')[0]).toEqual('99');
+  });
+
+  it('simple whitespace', () => {
+    expect(cleanUnicode('8\t\xA08')[0]).toEqual('88');
+  });
+});