stdnum 1.9.16 → 1.10.1

package/src/se/orgnr.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './orgnr';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('se/orgnr', () => {
+  it('format:1234567897', () => {
+    const result = format('1234567897');
+
+    expect(result).toEqual('123456-7897');
+  });
+
+  it('validate:1234567897', () => {
+    const result = validate('1234567897');
+
+    expect(result.isValid && result.compact).toEqual('1234567897');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:1234567891', () => {
+    const result = validate('1234567891');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/se/orgnr.ts

@@ -0,0 +1,68 @@
+/**
+ * Orgnr (Organisationsnummer, Swedish company number).
+ *
+ * The Orgnr (Organisationsnummer) is the national number to identify Swedish
+ * companies and consists of 10 digits. These are the first 10 digits in the
+ * Swedish VAT number, i.e. it's the VAT number without the 'SE' in front and
+ * the '01' at the end.
+ *
+ * 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: 'Swedish Company Number',
+  localName: 'Organisationsnummer',
+  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, -4).join('-');
+  },
+
+  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() };
+    }
+
+    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;

package/src/se/personnummer.spec.ts

@@ -0,0 +1,45 @@
+import { validate, format } from './personnummer';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('se/personnummer', () => {
+  test.each([
+    ['8803200017', '880320-0017'], // no hyphen assume young person
+    ['880320-0017', '880320-0017'], // standard format
+    ['880320+0017', '880320+0017'], // standard format, person over 100
+    ['19200901-0000', '200901+0000'], // 4digit year, hypen that's useless person over 100
+    ['192009010000', '200901+0000'], // 4digit year, no hyphen, person over 100
+    ['20200901-0000', '200901-0000'], // 4digit year, hyphen
+    ['202009010000', '200901-0000'], // 4digit year, no hyphen
+  ])('format:%s', (given, want) => {
+    const result = format(given);
+
+    expect(result).toEqual(want);
+  });
+
+  it('validate:880320-0016', () => {
+    const result = validate('880320-0016');
+
+    expect(result.isValid && result.compact).toEqual('880320-0016');
+  });
+
+  test.each(['811228-9874', '670919-9530', '11900102-2384'])(
+    '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:880320-0018', () => {
+    const result = validate('880320-0018');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/se/personnummer.ts

@@ -0,0 +1,143 @@
+/**
+ * Personnummer (Swedish personal identity number).
+ *
+ * The Swedish Personnummer is assigned at birth to all Swedish nationals and to
+ * immigrants for tax and identification purposes. The number consists of 10 or
+ * 12 digits and starts with the birth date, followed by a serial and a check
+ * digit.
+ *
+ * Source:
+ *    https://en.wikipedia.org/wiki/Personal_identity_number_(Sweden)
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { isValidDateCompactYYYYMMDD, buildDate, strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { luhnChecksumValidate } from '../util/checksum';
+
+const ONE_HUNDRED_YEARS_IN_MS = 100 * 365 * 24 * 60 * 60 * 1_000;
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' :');
+
+  if (err) {
+    return [value, err];
+  }
+
+  const [a, b, c] = strings.splitAt(value, -5, -4);
+
+  return [`${a.replace(/[-+]/g, '')}${b}${c}`, null];
+}
+
+function formatImpl(input: string): string {
+  const [value] = clean(input);
+
+  let front,
+    back,
+    sep = '-';
+
+  if (value.length === 12 || value.length === 13) {
+    const [yyyy, mm, dd] = strings.splitAt(value, 0, 4, 6, 8);
+
+    const d = buildDate(yyyy, mm, dd);
+    if (d === null) {
+      // bad date :(
+      return value;
+    }
+
+    if (new Date().getTime() - d.getTime() > ONE_HUNDRED_YEARS_IN_MS) {
+      sep = '+';
+    }
+
+    front = `${yyyy.substring(2)}${mm}${dd}`;
+
+    back = value.substring(value.length - 4);
+  } else if (value.length === 10) {
+    front = value.substring(0, 6);
+    back = value.substring(6);
+  } else if (value.length === 11) {
+    front = value.substring(0, 6);
+    sep = value[6];
+    back = value.substring(7);
+  } else {
+    return value;
+  }
+
+  return `${front}${sep}${back}`;
+}
+
+const impl: Validator = {
+  name: 'Swedish Personal Identity Number',
+  localName: 'Personnummer',
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value;
+  },
+
+  format: formatImpl,
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    let a, b, c;
+    if (value.length === 11) {
+      [a, b, c] = strings.splitAt(value, -5, -4);
+    } else if (value.length === 13) {
+      [, a, b, c] = strings.splitAt(value, -11, -5, -4);
+    } else {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!'-+'.includes(b)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    const digits = `${a}${c}`;
+    if (!strings.isdigits(digits)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    let yyyymmdd;
+    if (value.length === 13) {
+      yyyymmdd = value.substring(0, 8);
+    } else {
+      const yymmdd = value.substring(0, 6);
+      const year = new Date().getFullYear();
+      let century = Math.floor(year / 100);
+
+      if (parseInt(yymmdd.substring(0, 2), 10) > year % 100) {
+        century -= 1;
+      }
+      if (b === '+') {
+        century -= 1;
+      }
+
+      yyyymmdd = `${century}${yymmdd}`;
+    }
+    if (!isValidDateCompactYYYYMMDD(yyyymmdd, true)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    if (!luhnChecksumValidate(digits)) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: formatImpl(input),
+      isIndividual: true,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/se/vat.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './vat';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('se/vat', () => {
+  it('format:SE 123456789701', () => {
+    const result = format('SE 123456789701');
+
+    expect(result).toEqual('123456789701');
+  });
+
+  it('validate:SE 123456789701', () => {
+    const result = validate('SE 123456789701');
+
+    expect(result.isValid && result.compact).toEqual('123456789701');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:SE 123456789101', () => {
+    const result = validate('SE 123456789101');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/se/vat.ts

@@ -0,0 +1,73 @@
+/**
+ * VAT (Moms, Mervärdesskatt, Swedish VAT number).
+ *
+ * The Momsregistreringsnummer is used for VAT (Moms, Mervärdesskatt) purposes
+ * and consists of 12 digits of which the last two should be 01. The first 10
+ * digits should have a valid Luhn checksum.
+ *
+ * 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, ' -.', 'SE');
+}
+
+const impl: Validator = {
+  name: 'Swedish VAT Number',
+  localName: 'Momsregistreringsnummer',
+  abbreviation: 'Momsnr.',
+  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 !== 12) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, end] = strings.splitAt(value, -2);
+
+    if (end !== '01') {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (!luhnChecksumValidate(front)) {
+      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/sg/index.ts

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

package/src/sg/uen.spec.ts

@@ -0,0 +1,46 @@
+import { validate, format } from './uen';
+import { InvalidLength } from '../exceptions';
+
+describe('sg/uen', () => {
+  it('format:T01FC6132D', () => {
+    const result = format('T01FC6132D');
+
+    expect(result).toEqual('T01FC6132D');
+  });
+
+  it('validate:00192200M', () => {
+    const result = validate('00192200M');
+
+    expect(result.isValid && result.compact).toEqual('00192200M');
+  });
+
+  it('validate:197401143C', () => {
+    const result = validate('197401143C');
+
+    expect(result.isValid && result.compact).toEqual('197401143C');
+  });
+
+  it('validate:S16FC0121D', () => {
+    const result = validate('S16FC0121D');
+
+    expect(result.isValid && result.compact).toEqual('S16FC0121D');
+  });
+
+  it('validate:T01FC6132D', () => {
+    const result = validate('T01FC6132D');
+
+    expect(result.isValid && result.compact).toEqual('T01FC6132D');
+  });
+
+  it('validate:123456', () => {
+    const result = validate('123456');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  // it('validate:2449/494/16/0', () => {
+  //   const result = validate('2449/494/16/0');
+
+  //   expect(result.error).toBeInstanceOf(InvalidChecksum);
+  // });
+});

package/src/sg/uen.ts

@@ -0,0 +1,209 @@
+/**
+ * UEN (Singapore's Unique Entity Number).
+ *
+ * The Unique Entity Number (UEN) is a 9 or 10 digit identification issued by
+ * the government of Singapore to businesses that operate within Singapore.
+ * Accounting and Corporate Regulatory Authority (ACRA)
+ *
+ * There are three different formats:
+ * * Business (ROB): It consists of 8 digits followed by a check letter.
+ * * Local Company (ROC): It consists of 9 digits (the 4 leftmost digits
+ *   represent the year of issuance) followed by a check letter.
+ * * Others: Consists of 10 characters, begins with either the R letter, or the
+ *   S letter or the T letter followed by 2 digits representing the last two
+ *   digits of the issuance year, followed by two letters representing the
+ *   entity type, 4 digits and finally a check letter.
+ *
+ * Source
+ *   https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Singapore-TIN.pdf
+ *   https://www.uen.gov.sg/ueninternet/faces/pages/admin/aboutUEN.jspx
+ *
+ * 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, ' ');
+}
+
+const OTHER_UEN_ENTITY_TYPES = [
+  'CC',
+  'CD',
+  'CH',
+  'CL',
+  'CM',
+  'CP',
+  'CS',
+  'CX',
+  'DP',
+  'FB',
+  'FC',
+  'FM',
+  'FN',
+  'GA',
+  'GB',
+  'GS',
+  'HS',
+  'LL',
+  'LP',
+  'MB',
+  'MC',
+  'MD',
+  'MH',
+  'MM',
+  'MQ',
+  'NB',
+  'NR',
+  'PA',
+  'PB',
+  'PF',
+  'RF',
+  'RP',
+  'SM',
+  'SS',
+  'TC',
+  'TU',
+  'VH',
+  'XL',
+];
+
+function validateLocal(value: string): ValidateReturn {
+  const [front, check] = strings.splitAt(value, -1);
+  if (!strings.isdigits(front)) {
+    return { isValid: false, error: new exceptions.InvalidComponent() };
+  }
+
+  const sum = weightedSum(front, {
+    modulus: 11,
+    weights: [10, 8, 6, 4, 9, 7, 5, 3, 1],
+  });
+
+  const digit = 'ZKCMDNERGWH'[sum];
+
+  if (check !== digit) {
+    return { isValid: false, error: new exceptions.InvalidChecksum() };
+  }
+
+  return {
+    isValid: true,
+    compact: value,
+    isIndividual: false,
+    isCompany: true,
+  };
+}
+
+function validateBusiness(value: string): ValidateReturn {
+  const [front, check] = strings.splitAt(value, -1);
+  if (!strings.isdigits(front)) {
+    return { isValid: false, error: new exceptions.InvalidComponent() };
+  }
+
+  const sum = weightedSum(front, {
+    modulus: 11,
+    weights: [10, 4, 9, 3, 8, 2, 7, 1],
+  });
+
+  const digit = 'XMKECAWLJDB'[sum];
+
+  if (check !== digit) {
+    return { isValid: false, error: new exceptions.InvalidChecksum() };
+  }
+
+  return {
+    isValid: true,
+    compact: value,
+    isIndividual: false,
+    isCompany: true,
+  };
+}
+
+function validateOther(value: string): ValidateReturn {
+  const [kind, year, etype, rest, check] = strings.splitAt(value, 1, 3, 5, -1);
+  if (!['R', 'S', 'T'].includes(kind)) {
+    return { isValid: false, error: new exceptions.InvalidComponent() };
+  }
+  if (!strings.isdigits(year)) {
+    return { isValid: false, error: new exceptions.InvalidComponent() };
+  }
+
+  if (kind === 'T' && parseInt(year, 10) > new Date().getFullYear() % 100) {
+    return { isValid: false, error: new exceptions.InvalidComponent() };
+  }
+  if (!OTHER_UEN_ENTITY_TYPES.includes(etype)) {
+    return { isValid: false, error: new exceptions.InvalidComponent() };
+  }
+  if (!strings.isdigits(rest)) {
+    return { isValid: false, error: new exceptions.InvalidComponent() };
+  }
+  const alphabet = 'ABCDEFGHJKLMNPQRSTUVWX0123456789';
+
+  const digit =
+    alphabet[
+      (weightedSum(value.substr(0, 9), {
+        weights: [4, 3, 5, 3, 10, 2, 2, 5, 7],
+        modulus: 11,
+        alphabet,
+      }) +
+        6) %
+        11
+    ];
+
+  if (check !== digit) {
+    return { isValid: false, error: new exceptions.InvalidChecksum() };
+  }
+
+  return {
+    isValid: true,
+    compact: value,
+    isIndividual: false,
+    isCompany: true,
+  };
+}
+
+const impl: Validator = {
+  name: 'Singapore Unique Entity Number',
+  localName: 'Unique Entity Number',
+  abbreviation: 'UEN',
+  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 && value.length !== 10) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    if (value.length === 9) {
+      return validateBusiness(value);
+    }
+    if (strings.isdigits(value[0])) {
+      return validateLocal(value);
+    }
+
+    return validateOther(value);
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/si/ddv.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './ddv';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('si/ddv', () => {
+  it('format:SI 5022 3054', () => {
+    const result = format('SI 5022 3054');
+
+    expect(result).toEqual('50223054');
+  });
+
+  it('validate:SI 5022 3054', () => {
+    const result = validate('SI 5022 3054');
+
+    expect(result.isValid && result.compact).toEqual('50223054');
+  });
+
+  it('validate:1234567', () => {
+    const result = validate('1234567');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:SI 5022 3053', () => {
+    const result = validate('SI 5022 3053');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});