stdnum 1.10.0 → 1.10.1

package/src/th/moa.spec.ts

@@ -0,0 +1,62 @@
+import { validate, format } from './moa';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('th/moa', () => {
+  it('format:0993000133978', () => {
+    const result = format('0993000133978');
+
+    expect(result).toEqual('0-99-3-000-13397-8');
+  });
+
+  test.each([
+    '0994000617721',
+    '0-99-4-000-61772-1',
+    '0 10 5 544 04660 2',
+    '0 10 5 559 13643 2',
+    '0 10 5 560 07360 1',
+    '0 1055 43000 15 3',
+    '0 12 5 551 01213 1',
+    '0 19 5 554 00071 1',
+    '0 22 5 550 00051 1',
+    '0-10-3-541-01737-5',
+    '0-10-5-518-00189-3',
+    '0-10-5-539-13697-6',
+    '0-10-5-554-04636-2',
+    '0-7035-36000-78-2',
+    '0-99-2-002-50289-9',
+    '01055  6302 15 4 7',
+    '0105530041751',
+    '0105542067556',
+    '0105543014758',
+    '0105549020393',
+    '0105554084159',
+    '0105556000751',
+    '0105556142792',
+    '0115555008901',
+    '0115556023301',
+    '0245541000066',
+    '05  0  55440 03519',
+    '0655554000295',
+    '0713551000259',
+    '0745554003056',
+    '0992001001446',
+    '0992001158728',
+    '0992001526719',
+  ])('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:0-99-4-000-61772-3', () => {
+    const result = validate('0-99-4-000-61772-3');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/th/moa.ts

@@ -0,0 +1,85 @@
+/**
+ * MOA (Thailand Memorandum of Association Number).
+ *
+ * Memorandum of Association Number (aka Company's Taxpayer Identification
+ * Number) are numbers issued by the Department of Business Development.
+ * The number consists of 13 digits of which the last is a check digit following
+ * the same algorithm as in the Personal Identity Number (PIN). It uses a
+ * different grouping format and always starts with zero to indicate that the
+ * number issued by DBD.
+ *
+ * Source
+ *   https://www.dbd.go.th/download/pdf_kc/s09/busin_2542-48.pdf
+ *
+ * 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 impl: Validator = {
+  name: 'Thailand Memorandum of Association Number',
+  localName: '',
+  abbreviation: 'MOA',
+  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, 1, 3, 4, 7, 12).join('-');
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 13) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (value[0] !== '0') {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [front, check] = strings.splitAt(value, 12);
+
+    // same sum as IDNR
+    const sum = weightedSum(front, {
+      weights: [13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1],
+      modulus: 11,
+    });
+
+    if (String((11 - sum) % 10) !== check) {
+      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/th/tin.spec.ts

@@ -0,0 +1,77 @@
+import { validate, format } from './tin';
+import {
+  InvalidLength,
+  InvalidChecksum,
+  InvalidComponent,
+} from '../exceptions';
+
+describe('th/tin', () => {
+  it('format:1112034563562', () => {
+    const result = format('1112034563562');
+
+    expect(result).toEqual('1-1120-34563-56-2');
+  });
+
+  test.each([
+    '3100600445635',
+    '1-2345-45678-78-1',
+    '1112034563562',
+    '0 13 5 559 01262 8',
+    '0 20 5 560 00584 1',
+    '0 55 3 561 00041 5',
+    '0 74 5 561 00276 1',
+    '0-11-5-561-01623-6',
+    '0-2055-61011-25-0',
+    '0-2155-51001-61-8',
+    '0-3035-50001-80-8',
+    '0-33-3-558-00060-6',
+    '0-47-5-562-00062-4',
+    '0-58-3-558-00012-4',
+    '0-73-5-561-00588-3',
+    '0-7355-56003-30-4',
+    '0105552029681',
+    '0105559074461',
+    '0343559002742',
+    '0403552000484',
+    '0835561014091',
+    '1 1020 01865 33 1',
+    '1 3501 00018 05 5',
+    '1-40-9-900-07433-0',
+    '1-4701-00062-82-7',
+    '1-56-0-300-01581-3',
+    '1-6707-00016-13-1',
+    '1-8399-00112-47-5',
+    '1129900166199',
+    '1509900258294',
+    '1939990003289',
+    '2-30-9-900-00391-1',
+    '3 2001 00052 57 9',
+    '3 5099 01429 67 6',
+    '3-10-1-201-21325-1',
+    '3-1907-00075-74-1',
+    '5-49-0-200-01960-8',
+    '8 4799 88011 44 1',
+  ])('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:0101700230705', () => {
+    const result = validate('0101700230705');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:1101700230705', () => {
+    const result = validate('1101700230705');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});

package/src/th/tin.ts

@@ -0,0 +1,56 @@
+/**
+ * TIN (Thailand Taxpayer Identification Number).
+ *
+ * The Taxpayer Identification Number is used for tax purposes in the Thailand.
+ * This number consists of 13 digits which the last is a check digit.
+ * Personal income taxpayers use Personal Identification Number (IDNR) while
+ * companies use Memorandum of Association (MOA).
+ *
+ * Source
+ *
+ * ENTITY/PERSON
+ */
+
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import * as idnr from './idnr';
+import * as moa from './moa';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const impl: Validator = {
+  name: 'Thailand 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 {
+    if (idnr.validate(input).isValid) {
+      return idnr.format(input);
+    }
+    return moa.format(input);
+  },
+
+  validate(input: string): ValidateReturn {
+    const v1 = idnr.validate(input);
+    if (v1.isValid) {
+      return v1;
+    }
+
+    return moa.validate(input);
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/tn/index.ts

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

package/src/tn/mf.spec.ts

@@ -0,0 +1,37 @@
+import { validate, format } from './mf';
+import { InvalidComponent, InvalidFormat } from '../exceptions';
+
+describe('tn/mf', () => {
+  it('format:1496298 T P N 000', () => {
+    const result = format('1496298 T P N 000');
+
+    expect(result).toEqual('1496298/T/P/N/000');
+  });
+
+  it('fvalidate:121J', () => {
+    const result = validate('121J');
+
+    expect(result.isValid && result.compact).toEqual('0000121J');
+  });
+
+  test.each(['1234567/M/A/E/001', '1282182 W', '121J'])(
+    'validate:%s',
+    value => {
+      const result = validate(value);
+
+      expect(result.isValid).toEqual(true);
+    },
+  );
+
+  it('validate:aaaaaaa/M/A/E/abc', () => {
+    const result = validate('aaaaaaa/M/A/E/abc');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:1234567/M/A/X/000', () => {
+    const result = validate('1234567/M/A/X/000');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});

package/src/tn/mf.ts

@@ -0,0 +1,169 @@
+/**
+ * MF (Matricule Fiscal, Tunisia tax number).
+ *
+ * The MF consists of 4 parts: the "identifiant fiscal", the "code TVA", the "code
+ * catégorie" and the "numéro d'etablissement secondaire".
+ *
+ * The "identifiant fiscal" consists of 2 parts: the "identifiant unique" and the
+ * "clef de contrôle". The "identifiant unique" is composed of 7 digits. The "clef
+ * de contrôle" is a letter, excluding "I", "O" and "U" because of their
+ * similarity to "1", "0" and "4".
+ *
+ * The "code TVA" is a letter that tells which VAT regime is being used. The valid
+ * values are "A", "P", "B", "D" and "N".
+ *
+ * The "code catégorie" is a letter that tells the category the contributor
+ * belongs to. The valid values are "M", "P", "C", "N" and "E".
+ *
+ * The "numéro d'etablissement secondaire" consists of 3 digits. It is usually
+ * "000", but it can be "001", "002"... depending on the branches. If it is not
+ * "000" then "code catégorie" must be "E".
+ *
+ * Source
+ *   https://futurexpert.tn/2019/10/22/structure-et-utilite-du-matricule-fiscal/
+ *   https://www.registre-entreprises.tn/
+ *
+ * VAT
+ */
+
+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 = /^(\d+)(.*)$/;
+
+function compactImpl(input: string): ReturnType<typeof strings.cleanUnicode> {
+  const [value, err] = clean(input);
+
+  if (err) {
+    return ['', err];
+  }
+
+  const match = value.match(validRe);
+
+  if (match && match.length === 3) {
+    return [match[1].padStart(7, '0') + match[2], null];
+  }
+
+  return [value, null];
+}
+
+const VALID_CONTROL_KEYS = [
+  'A',
+  'B',
+  'C',
+  'D',
+  'E',
+  'F',
+  'G',
+  'H',
+  'J',
+  'K',
+  'L',
+  'M',
+  'N',
+  'P',
+  'Q',
+  'R',
+  'S',
+  'T',
+  'V',
+  'W',
+  'X',
+  'Y',
+  'Z',
+];
+const VALID_TVA_CODES = ['A', 'P', 'B', 'D', 'N'];
+const VALID_CATEGORY_CODES = ['M', 'P', 'C', 'N', 'E'];
+
+const impl: Validator = {
+  name: 'Tunisia tax number',
+  localName: 'Matricule Fiscal',
+  abbreviation: 'MF',
+
+  compact(input: string): string {
+    const [value, error] = compactImpl(input);
+
+    if (error) {
+      throw error;
+    }
+
+    return value;
+  },
+
+  format(input: string): string {
+    const [value, error] = compactImpl(input);
+
+    if (error) {
+      return input;
+    }
+
+    const [front, key, tva, category, rest] = strings.splitAt(
+      value,
+      7,
+      8,
+      9,
+      10,
+    );
+
+    if (value.length === 8) {
+      return `${front}/${key}`;
+    }
+
+    return `${front}/${key}/${tva}/${category}/${rest}`;
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = compactImpl(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 8 && value.length !== 13) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+
+    const [front, key, tva, category, rest] = strings.splitAt(
+      value,
+      7,
+      8,
+      9,
+      10,
+    );
+
+    if (!strings.isdigits(front)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (!VALID_CONTROL_KEYS.includes(key)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (value.length !== 8) {
+      if (!VALID_TVA_CODES.includes(tva)) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (!VALID_CATEGORY_CODES.includes(category)) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (!strings.isdigits(rest)) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (rest !== '000' && category !== 'E') {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/tr/index.ts

@@ -0,0 +1,2 @@
+export * as tckimlik from './tckimlik';
+export * as vkn from './vkn';

package/src/tr/tckimlik.spec.ts

@@ -0,0 +1,40 @@
+import { validate, format } from './tckimlik';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('tr/tckimlik', () => {
+  it('format:17291716060', () => {
+    const result = format('17291716060');
+
+    expect(result).toEqual('17291716060');
+  });
+
+  it('validate:17291716060', () => {
+    const result = validate('17291716060');
+
+    expect(result.isValid && result.compact).toEqual('17291716060');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:17291716050', () => {
+    const result = validate('17291716050');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:64211142102', () => {
+    const result = validate('64211142102');
+
+    expect(result.isValid && result.compact).toEqual('64211142102');
+  });
+
+  it('validate:62345678900', () => {
+    const result = validate('62345678900');
+
+    expect(result.isValid && result.compact).toEqual('62345678900');
+  });
+});

package/src/tr/tckimlik.ts

@@ -0,0 +1,87 @@
+/**
+ * T.C. Kimlik No. (Turkish personal identification number)
+ *
+ * The Turkish Identification Number (Türkiye Cumhuriyeti Kimlik Numarası) is a
+ * unique personal identification number assigned to every citizen of Turkey.
+ * The number consists of 11 digits and the last two digits are check digits.
+ *
+ * Source:
+ *   https://en.wikipedia.org/wiki/Turkish_Identification_Number
+ *   https://tckimlik.nvi.gov.tr/
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings, weightedSum } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, '');
+}
+
+const impl: Validator = {
+  name: 'Turkish Identificatio Number',
+  localName: 'Türkiye Cumhuriyeti Kimlik Numarası',
+  abbreviation: 'T.C. Kimlik 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 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 (!strings.isdigits(value) || value[0] === '0') {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, check] = strings.splitAt(value, -2);
+
+    const sum1 =
+      (10 -
+        weightedSum(front, {
+          weights: [3, 1],
+          modulus: 10,
+        })) %
+      10;
+    const sum2 =
+      (sum1 +
+        weightedSum(front, {
+          weights: [1],
+          modulus: 10,
+        })) %
+      10;
+
+    if (`${sum1}${sum2}` !== 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/tr/vkn.spec.ts

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