stdnum 1.10.0 → 1.10.1

package/src/gb/utr.spec.ts

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

package/src/gb/utr.ts

@@ -0,0 +1,76 @@
+/**
+ * UTR (United Kingdom Unique Taxpayer Reference).
+ *
+ * A UTR (unique taxpayer reference) is a 10 digit number used to identify UK
+ * taxpayers who have to submit a tax return.
+ *
+ * Source
+ *    https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/UK-TIN.pdf
+ *
+ * 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: 'United Kingdom Unique Taxpayer Reference',
+  localName: 'Unique Taxpayer Reference',
+  abbreviation: 'UTR',
+
+  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 [check, back] = strings.splitAt(value, 1);
+    const sum = weightedSum(back, {
+      weights: [6, 7, 8, 9, 10, 5, 4, 3, 2],
+      modulus: 11,
+    });
+    const digit = '21987654321'[sum];
+    if (digit !== 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/gb/vat.spec.ts

@@ -0,0 +1,40 @@
+import { validate, format } from './vat';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('gb/vat', () => {
+  it('format:GB 980 7806 84', () => {
+    const result = format('GB 980 7806 84');
+
+    expect(result).toEqual('980 7806 84');
+  });
+
+  it('validate:GB 980 7806 84', () => {
+    const result = validate('GB 980 7806 84');
+
+    expect(result.isValid && result.compact).toEqual('980780684');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:802311781', () => {
+    const result = validate('802311781');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:GB340804329', () => {
+    const result = validate('GB340804329');
+
+    expect(result.isValid && result.compact).toEqual('340804329');
+  });
+
+  it('validate:GB346270013', () => {
+    const result = validate('GB346270013');
+
+    expect(result.isValid && result.compact).toEqual('346270013');
+  });
+});

package/src/gb/vat.ts

@@ -0,0 +1,112 @@
+/**
+ * VAT (United Kingdom (and Isle of Man) VAT registration number).
+ *
+ * The VAT number can either be a 9-digit standard number, a 12-digit standard
+ * number followed by a 3-digit branch identifier, a 5-digit number for
+ * government departments (first two digits are GD) or a 5-digit number for
+ * health authorities (first two digits are HA). The 9-digit variants use a
+ * weighted checksum.
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = strings.cleanUnicode(input, ' -/');
+  if (err !== null) {
+    return [value, err];
+  }
+  if (value.startsWith('GB')) {
+    return [value.substr(2), null];
+  }
+  return [value, null];
+}
+
+const impl: Validator = {
+  name: 'United Kingdom (and Isle of Man) VAT Number',
+  localName: 'Value Added Tax Registration Number',
+  abbreviation: 'VAT Reg No',
+  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 === 5) {
+      if (!strings.isdigits(value.substr(2))) {
+        return { isValid: false, error: new exceptions.InvalidFormat() };
+      }
+      const cvalue = parseInt(value.substr(2), 10);
+      if (value.startsWith('GD') && cvalue >= 500) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (value.startsWith('HA') && cvalue < 500) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+    } else if (
+      value.length === 11 &&
+      (value.startsWith('GD8888') || value.startsWith('HA8888'))
+    ) {
+      if (!strings.isdigits(value.substr(6))) {
+        return { isValid: false, error: new exceptions.InvalidFormat() };
+      }
+      const cvalue = parseInt(value.substr(6, 3), 10);
+      if (value.startsWith('GD') && cvalue >= 500) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (value.startsWith('HA') && cvalue < 500) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (cvalue % 97 !== parseInt(value.substr(9, 2), 10)) {
+        return { isValid: false, error: new exceptions.InvalidChecksum() };
+      }
+    } else if (value.length === 9 || value.length === 12) {
+      if (!strings.isdigits(value)) {
+        return { isValid: false, error: new exceptions.InvalidFormat() };
+      }
+      const sum = weightedSum(value.substr(0, 9), {
+        weights: [8, 7, 6, 5, 4, 3, 2, 10, 1],
+        modulus: 97,
+      });
+      if (Number(value.substring(0, 3)) >= 100) {
+        if (![0, 42, 55].includes(sum)) {
+          return { isValid: false, error: new exceptions.InvalidChecksum() };
+        }
+      } else if (sum !== 0) {
+        return { isValid: false, error: new exceptions.InvalidChecksum() };
+      }
+    } else {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: true,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/gen/ean.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './ean';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('gen/ean', () => {
+  it('format:73513537', () => {
+    const result = format('73513537');
+
+    expect(result).toEqual('73513537');
+  });
+
+  it('validate:978-0-471-11709-4', () => {
+    const result = validate('978-0-471-11709-4');
+
+    expect(result.isValid && result.compact).toEqual('9780471117094');
+  });
+
+  it('validate:98412345678908', () => {
+    const result = validate('98412345678908');
+
+    expect(result.isValid && result.compact).toEqual('98412345678908');
+  });
+
+  it('validate:123456789', () => {
+    const result = validate('123456789');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:98412345678907', () => {
+    const result = validate('98412345678907');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/gen/ean.ts

@@ -0,0 +1,71 @@
+/**
+ * EAN (International Article Number).
+ *
+ * This handles numbers EAN-13, EAN-8, UPC (12-digit)
+ * and GTIN (EAN-14) format.
+ */
+
+import * as exceptions from '../exceptions';
+import * as strings from '../util/strings';
+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: 'International Article Number',
+  localName: 'International Article Number',
+  abbreviation: 'EAN',
+  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 (![8, 12, 13, 14].includes(value.length)) {
+      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: 10,
+      weights: [3, 1],
+      reverse: true,
+    });
+
+    if (String((10 - sum) % 10) !== check) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/gen/index.ts

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

package/src/gh/index.ts

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

package/src/gh/tin.spec.ts

@@ -0,0 +1,42 @@
+import { validate, format } from './tin';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('gn/tin', () => {
+  it('format:C0000803561', () => {
+    const result = format('C0000803561');
+
+    expect(result).toEqual('C0000803561');
+  });
+
+  it('fvalidate:C0000803561', () => {
+    const result = validate('C0000803561');
+
+    expect(result.isValid && result.compact).toEqual('C0000803561');
+  });
+
+  test.each([
+    'C0000803561',
+    'C0002147866',
+    'C001095242X',
+    'C000366497X',
+    'G0061140708',
+    'V0003107108',
+    'P0008816751',
+  ])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate:C000080356', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:C0000803562', () => {
+    const result = validate('C0000803562');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/gh/tin.ts

@@ -0,0 +1,93 @@
+/**
+ * TIN (Taxpayer Identification Number, Ghana tax number).
+ * 
+ * This number is issued by the Ghana Revenue Authority (GRA) to individuals who
+ * are not eligible for the Ghanacard PIN and other entities.
+ * This number consists of 11 alpha-numeric characters. It begins with one of the
+ * following prefixes:
+ *   P00 For Individuals.
+ *   C00 For Companies limited by guarantee, shares, Unlimited (i.e organisation
+ *       required to register with the RGD).
+ *   G00 Government Agencies, MDAs.
+ *   Q00 Foreign Missions, Employees of foreign missions.
+ *   V00 Public Institutions, Trusts, Co-operatives, Foreign Shareholder
+ *       (Offshore), (Entities not registered by RGD).
+ * 
+ * Source
+ *   https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Ghana-TIN.pdf
+ *   https://gra.gov.gh/tin/
+ *   https://gra.gov.gh/tin/tin-faq/
+
+ * ENTITY/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 validRe = /^[PCGQV]{1}00[A-Z0-9]{8}$/;
+
+const ALPHABET = '0123456789X';
+
+const impl: Validator = {
+  name: 'Taxpayer Identification Number',
+  localName: '',
+  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 value;
+  },
+
+  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() };
+    }
+
+    const [, front, check] = strings.splitAt(value, 1, 10);
+
+    const sum = weightedSum(front, {
+      weights: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+      modulus: 11,
+    });
+
+    if (ALPHABET[sum] !== check) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: value[0] === 'P',
+      isCompany: value[0] !== 'P',
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/gn/index.ts

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

package/src/gn/nifp.spec.ts

@@ -0,0 +1,40 @@
+import { validate, format } from './nifp';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('gn/nifp', () => {
+  it('format:693770885', () => {
+    const result = format('693770885');
+
+    expect(result).toEqual('693-770-885');
+  });
+
+  it('fvalidate:693-770-885', () => {
+    const result = validate('693-770-885');
+
+    expect(result.isValid && result.compact).toEqual('693770885');
+  });
+
+  test.each([
+    '693770885',
+    '693-770-885',
+    '102193364',
+    '330284803',
+    '447777913',
+  ])('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:693770884', () => {
+    const result = validate('693770884');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/gn/nifp.ts

@@ -0,0 +1,72 @@
+/**
+ * NIFp (Numéro d'Identification Fiscale Permanent, Guinea tax number).
+ * 
+ * This number consists of 9 digits, usually separated into three groups using
+ * hyphens to make it easier to read. The first eight digits are assigned in a
+ * pseudorandom manner. The last digit is the check digit.
+ * 
+ * Source
+ *   https://dgi.gov.gn/wp-content/uploads/2022/09/N%C2%B0-12-Cahier-de-Charges-NIF-p.pdf
+
+ * ENTITY/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: "Numéro d'Identification Fiscale Permanent",
+  localName: '',
+  abbreviation: 'NIFP',
+
+  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, 6).join('-');
+  },
+
+  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 (!luhnChecksumValidate(value)) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/gr/amka.spec.ts

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