stdnum 1.10.0 → 1.10.2

package/src/by/unp.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './unp';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('by/unp', () => {
+  it('format:200988541', () => {
+    const result = format('200988541');
+
+    expect(result).toEqual('200988541');
+  });
+
+  it('validate:200988541', () => {
+    const result = validate('200988541');
+
+    expect(result.isValid && result.compact).toEqual('200988541');
+  });
+
+  it('validate:УНП MA1953684', () => {
+    const result = validate('УНП MA1953684');
+
+    expect(result.isValid && result.compact).toEqual('MA1953684');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:200988542', () => {
+    const result = validate('200988542');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/by/unp.ts

@@ -0,0 +1,108 @@
+/**
+ * УНП, UNP (Учетный номер плательщика, the Belarus VAT number).
+ *
+ * The УНП (UNP) or Учетный номер плательщика (Uchetniy nomer platel'shika,
+ * Payer account number) is issued to organisations and individuals for tax
+ * purposes. The number consists of 9 digits (numeric for organisations,
+ * alphanumeric for individuals) and contains a region identifier, a serial per
+ * region and a check digit.
+ *
+ * Source
+ *   https://be.wikipedia.org/wiki/Уліковы_нумар_плацельшчыка
+ *   http://pravo.levonevsky.org/bazaby09/sbor37/text37892/index3.htm
+ *
+ * PERSON/ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { weightedSum } from '../util/checksum';
+
+const PREFIX = ['УНП', 'УНП', 'UNP', 'UNP'];
+const alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' -/');
+
+  if (err !== null) {
+    return [value, err];
+  }
+
+  const v2 = PREFIX.reduce(
+    (acc: string | null, p) =>
+      acc || (!value.startsWith(p) ? acc : value.substr(p.length)),
+    null,
+  );
+
+  return [v2 ?? value, null];
+}
+
+const impl: Validator = {
+  name: 'Belarus VAT Number',
+  localName: 'Учетный номер плательщика',
+  abbreviation: 'УНП (UNP)',
+  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.substr(2))) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!strings.isdigits(value[0]) && !'1234567ABCEHKM'.includes(value[0])) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!strings.isdigits(value[1]) && !'ABCEHKMOPT'.includes(value[1])) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, check] = strings.splitAt(value, -1);
+
+    let frontClean = front;
+    if (!strings.isdigits(front.substr(0, 2))) {
+      const vv = String('ABCEHKMOPT'.indexOf(front[1]));
+      frontClean = `${front[0]}${vv}${front.substr(2)}`;
+    }
+
+    const sum = weightedSum(frontClean, {
+      modulus: 11,
+      weights: [29, 23, 19, 17, 13, 7, 5, 3],
+      alphabet,
+    });
+
+    if (sum === 10 || String(sum) !== check) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: true,
+      isCompany: true,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/bz/index.ts

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

package/src/bz/tin.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './tin';
+import { InvalidLength, InvalidComponent } from '../exceptions';
+
+describe('bz/tin', () => {
+  it('format:00000510', () => {
+    const result = format('00000510');
+
+    expect(result).toEqual('000005-10');
+  });
+
+  it('validate:00000510', () => {
+    const result = validate('00000510');
+
+    expect(result.isValid && result.compact).toEqual('00000510');
+  });
+
+  it('validate:0000051', () => {
+    const result = validate('0000051');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:00000520', () => {
+    const result = validate('00000520');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});

package/src/bz/tin.ts

@@ -0,0 +1,67 @@
+/**
+ * TIN (Belize Tax ID)
+ *
+ * Source
+ *    https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Belize-TIN.pdf
+ *
+ * PERSON/ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const impl: Validator = {
+  name: 'Belize Tax Identification Number',
+  localName: 'Tax Identification Number',
+  abbreviation: 'TIN',
+
+  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 !== 6 && value.length !== 8) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    const [, code] = strings.splitAt(value, 6);
+
+    if (code && !['10', '13', '66'].includes(code)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: code === '10',
+      isCompany: code === '13' || code === '66',
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/ca/bn.spec.ts

@@ -0,0 +1,40 @@
+import { validate, format } from './bn';
+import { InvalidLength, InvalidChecksum, InvalidFormat } from '../exceptions';
+
+describe('ca/bn', () => {
+  it('format:123026635RC0001', () => {
+    const result = format('123026635RC0001');
+
+    expect(result).toEqual('12302 6635 RC 0001');
+  });
+
+  it('validate:12302 6635 RC 0001', () => {
+    const result = validate('12302 6635 RC 0001');
+
+    expect(result.isValid && result.compact).toEqual('123026635RC0001');
+  });
+
+  it('validate:12302 6635', () => {
+    const result = validate('12302 6635');
+
+    expect(result.isValid && result.compact).toEqual('123026635');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:12345678Z', () => {
+    const result = validate('12345678Z');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:123456783', () => {
+    const result = validate('123456783');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/ca/bn.ts

@@ -0,0 +1,88 @@
+/**
+ * BN (Canadian Business Number).
+ *
+ * A Business Number (BN) is a 9-digit identification number for businesses
+ * issued by the Canada Revenue Agency for tax purposes. The 9-digit number can
+ * be followed by two letters (program identifier) and 4 digits (reference
+ * number) to form a program account (or BN15).
+ *
+ * Source:
+ *   https://www.canada.ca/en/services/taxes/business-number.html
+ *   https://www.ic.gc.ca/app/scr/cc/CorporationsCanada/fdrlCrpSrch.html?locale=en_CA/
+ *
+ *
+ * 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: 'Canadian Business Number',
+  localName: 'Business Number',
+  abbreviation: 'BN',
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value;
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    if (value.length === 15) {
+      return strings.splitAt(value, 5, 9, 11).join(' ');
+    }
+    return strings.splitAt(value, 5).join(' ');
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 9 && value.length !== 15) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    const [front, rest] = strings.splitAt(value, 9);
+    if (!strings.isdigits(front)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!luhnChecksumValidate(front)) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    if (rest) {
+      const [a, b] = strings.splitAt(rest, 2);
+
+      if (!['RC', 'RM', 'RP', 'RT'].includes(a)) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (!strings.isdigits(b)) {
+        return { isValid: false, error: new exceptions.InvalidFormat() };
+      }
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: true,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/ca/gst.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './gst';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('ca/gst', () => {
+  it('format:754039725 RT 0001', () => {
+    const result = format('754039725 RT 0001');
+
+    expect(result).toEqual('754039725RT0001');
+  });
+
+  it('fvalidate:754039725 RT 0001', () => {
+    const result = validate('754039725 RT 0001');
+
+    expect(result.isValid && result.compact).toEqual('754039725RT0001');
+  });
+
+  test.each(['807138417RT0001', '754039725 RT 0001'])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate:VALUE', () => {
+    const result = validate('VALUE');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:754039729 RT 0001', () => {
+    const result = validate('754039729 RT 0001');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/ca/gst.ts

@@ -0,0 +1,70 @@
+/**
+ * GST (Canadian Sales Tax Number)
+ *
+ * It is the BN in a extensive form.
+ *   9 digits - Business number to identify the business. It is the Bussines Number.
+ *   2 alpha - A reference number to identify each account a business may have within a program type.
+ *   4 digits - A reference number to identify each account a business may have within a program type.
+ *
+ * Source
+ *   https://wiki.scn.sap.com/wiki/display/CRM/Canada
+ *   https://www.canada.ca/en/revenue-agency/cra-canada.html
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { validate as bnValidate } from './bn';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const validRe = /^\d{9}[A-Z]{2}\d{4}$/i;
+
+// const ALPHABET = '0123456789X';
+
+const impl: Validator = {
+  name: 'Goods and service Tax Number',
+  localName: 'Goods and service Tax Number',
+  abbreviation: 'GST',
+
+  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 !== 15) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    if (!validRe.test(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    // The BN15 is the same as a GST
+    return bnValidate(value);
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/ca/index.ts

@@ -0,0 +1,5 @@
+export * as bn from './bn';
+export * as sin from './sin';
+export * as gst from './gst';
+export * as qst from './qst';
+export * as pst from './pst';

package/src/ca/pst.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './pst';
+import { InvalidLength } from '../exceptions';
+
+describe('ca/pst', () => {
+  it('format:PST12345678', () => {
+    const result = format('PST12345678');
+
+    expect(result).toEqual('PST-1234-5678');
+  });
+
+  it('fvalidate:PST-1234-5678', () => {
+    const result = validate('PST-1234-5678');
+
+    expect(result.isValid && result.compact).toEqual('PST12345678');
+  });
+
+  test.each(['PST-1234-5678'])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate:PST-1234-567', () => {
+    const result = validate('PST-1234-567');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+});

package/src/ca/pst.ts

@@ -0,0 +1,71 @@
+/**
+ * PST (Canadian BC Provincial Sales Tax)
+ *
+ * 3 alphanumeric (PST)
+ * 8 digits
+ *
+ * Source
+ *   https://wiki.scn.sap.com/wiki/display/CRM/Canada
+ *   https://www2.gov.bc.ca/gov/content/taxes/sales-taxes/pst/register
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const validRe = /^PST\d{8}$/;
+
+// const ALPHABET = '0123456789X';
+
+const impl: Validator = {
+  name: 'Provincial Sales Tax',
+  localName: '',
+  abbreviation: 'PST',
+
+  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, 7).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 (!validRe.test(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: true,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/ca/qst.spec.ts

@@ -0,0 +1,47 @@
+import { validate, format } from './qst';
+import {
+  InvalidLength,
+  InvalidChecksum,
+  InvalidComponent,
+} from '../exceptions';
+
+describe('ca/qst', () => {
+  it('format:1224002901 TQ 0001', () => {
+    const result = format('1224002901 TQ 0001');
+
+    expect(result).toEqual('1224002901TQ0001');
+  });
+
+  it('fvalidate:1224002901 TQ 0001', () => {
+    const result = validate('1224002901 TQ 0001');
+
+    expect(result.isValid && result.compact).toEqual('1224002901TQ0001');
+  });
+
+  test.each(['1224002901 TQ 0001', '1214326422TQ0001'])(
+    'validate:%s',
+    value => {
+      const result = validate(value);
+
+      expect(result.isValid).toEqual(true);
+    },
+  );
+
+  it('validate:1224002901 TQ 000', () => {
+    const result = validate('1224002901 TQ 000');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:1224002902 TQ 0001', () => {
+    const result = validate('1224002902 TQ 0001');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:1224002901 TQ 0000', () => {
+    const result = validate('1224002901 TQ 0000');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});