stdnum 1.10.0 → 1.10.2

package/src/pt/cc.spec.ts

@@ -0,0 +1,43 @@
+import { validate, format } from './cc';
+import { InvalidLength, InvalidChecksum, InvalidFormat } from '../exceptions';
+
+describe('pt/cc', () => {
+  it('format:000000000ZZ4', () => {
+    const result = format('000000000ZZ4');
+
+    expect(result).toEqual('00000000 0 ZZ4');
+  });
+
+  it('validate:10000000 0 ZZ2', () => {
+    const result = validate('10000000 0 ZZ2');
+
+    expect(result.isValid && result.compact).toEqual('100000000ZZ2');
+  });
+
+  test.each(['04521224 4 ZZ 7', '054546796ZY7', '101490801ZY0'])(
+    'validate:%s',
+    value => {
+      const result = validate(value);
+
+      expect(result.isValid).toEqual(true);
+    },
+  );
+
+  it('validate:00000000 0 ZZ', () => {
+    const result = validate('00000000 0 ZZ');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:00000000 A ZZ4', () => {
+    const result = validate('00000000 A ZZ4');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:10000000 0 ZZ4', () => {
+    const result = validate('10000000 0 ZZ4');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/pt/cc.ts

@@ -0,0 +1,74 @@
+/**
+ * CC (Número de Cartão de Cidadão, Portuguese Identity number).
+ *
+ * The Portuguese Identity Number is alphanumeric and consists of the numeric
+ * Número de Identificação Civil, a two-letter version and a check digit.
+ *
+ * Source
+ *   https://pt.wikipedia.org/wiki/Cartão_de_cidadão
+ *   https://www.autenticacao.gov.pt/documents/20126/115760/Validação+de+Número+de+Documento+do+Cartão+de+Cidadão.pdf
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { luhnChecksumValidate } from '../util/checksum';
+
+const ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const validRe = /^\d{9}[A-Z0-9]{2}\d$/i;
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' ');
+}
+
+const impl: Validator = {
+  name: 'Portuguese Identity number',
+  localName: 'Número de Cartão de Cidadão',
+  abbreviation: 'CC',
+
+  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, 8, 9).join(' ');
+  },
+
+  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 (!validRe.test(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (!luhnChecksumValidate(value, ALPHABET)) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: '1234'.includes(value[0]),
+      isCompany: !'1234'.includes(value[0]),
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/pt/index.ts

@@ -0,0 +1,3 @@
+export * as cc from './cc';
+export * as nif from './nif';
+export * as nipc from './nipc';

package/src/pt/nif.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './nif';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('pt/nif', () => {
+  it('format:PT 501 964 843', () => {
+    const result = format('PT 501 964 843');
+
+    expect(result).toEqual('501 964 843');
+  });
+
+  it('validate:PT 501 964 843', () => {
+    const result = validate('PT 501 964 843');
+
+    expect(result.isValid && result.compact).toEqual('501964843');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:PT 501 964 842', () => {
+    const result = validate('PT 501 964 842');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/pt/nif.ts

@@ -0,0 +1,78 @@
+/**
+ * NIF (Número de identificação fiscal, Portuguese VAT number).
+ *
+ * The NIF (Número de identificação fiscal, NIPC, Número de Identificação de
+ * Pessoa Colectiva) is used for VAT purposes. It is a 9-digit number with a
+ * simple checksum. The first digit depends on what the number refers to,
+ * e.g.: 1-3 are regular people, 5 are companies.
+ *
+ * Source
+ * https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Portugal-TIN.pdf
+ *
+ * PERSON/ENTITY
+ */
+
+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, ' -.', 'PT');
+}
+
+const impl: Validator = {
+  name: 'Portuguese Tax Identification Number',
+  localName: 'Número de Identificação Fiscal',
+  abbreviation: 'NIF',
+
+  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) || value[0] === '0') {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [front, check] = strings.splitAt(value, -1);
+
+    const sum = weightedSum(front, {
+      weights: [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: '1234'.includes(value[0]),
+      isCompany: !'1234'.includes(value[0]),
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/pt/nipc.ts

@@ -0,0 +1,27 @@
+/**
+ * NIPC (Número de Identificação de Pessoa Coletiva, Portuguese VAT number).
+ *
+ * The NIF (Número de identificação fiscal, NIPC, Número de Identificação de
+ * Pessoa Colectiva) is used for VAT purposes. It is a 9-digit number with a
+ * simple checksum. The first digit depends on what the number refers to,
+ * e.g.: 1-3 are regular people, 5 are companies.
+ *
+ * Source
+ * https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Portugal-TIN.pdf
+ *
+ * PERSON/ENTITY
+ */
+
+import * as nif from './nif';
+
+import { Validator } from '../types';
+
+const impl: Validator = {
+  ...nif,
+  name: 'Portuguese Legal Person Identification Number',
+  localName: 'Número de Identificação de Pessoa Colectiva',
+  abbreviation: 'NIPC',
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/py/cedula.spec.ts

@@ -0,0 +1,46 @@
+import { validate, format } from './cedula';
+import { InvalidComponent, InvalidLength } from '../exceptions';
+
+describe('py/ci', () => {
+  it('format:6.001.234', () => {
+    const result = format('6.001.234');
+
+    expect(result).toEqual('6001234');
+  });
+
+  it('validate:15000', () => {
+    const result = validate('15000');
+
+    expect(result.isValid && result.compact).toEqual('15000');
+  });
+
+  it('validate:3 785 123', () => {
+    const result = validate('3 785 123');
+
+    expect(result.isValid && result.compact).toEqual('3785123');
+  });
+
+  it('validate:6-001-234', () => {
+    const result = validate('6-001-234');
+
+    expect(result.isValid && result.compact).toEqual('6001234');
+  });
+
+  it('validate:660.3', () => {
+    const result = validate('660.3');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:26601234', () => {
+    const result = validate('26601234');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:266012A', () => {
+    const result = validate('266012A');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});

package/src/py/cedula.ts

@@ -0,0 +1,73 @@
+/**
+ *
+ * Paraguay Identity Card numbers
+ *
+ * CI number (Cedula de la Identidad Civil).
+ *
+ * The Cedula de la Identidad (CI) is issued by the National Police and is compulsory for all citizens
+ *
+ * The CI number is 5-7 digits.
+ *
+ * Sources:
+ *     https://es.wikipedia.org/wiki/C%C3%A9dula_de_Identidad_(Paraguay)
+ *
+ * PERSON
+ */
+
+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: 'Paraguay CI Number',
+  localName: 'Cedula de la Identidad civil',
+  abbreviation: 'CI',
+  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;
+  },
+
+  /**
+   * Check if the number is a valid CI.
+   * This checks the length, formatting and other contraints.
+   *
+   */
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length < 5 || value.length > 7) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(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/py/index.ts

@@ -0,0 +1,2 @@
+export * as ruc from './ruc';
+export * as cedula from './cedula';

package/src/py/ruc.spec.ts

@@ -0,0 +1,40 @@
+import { validate, format } from './ruc';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('py/ruc', () => {
+  it('format:800280610', () => {
+    const result = format('80028061 0');
+
+    expect(result).toEqual('80028061-0');
+  });
+
+  it('validate:80028061-0', () => {
+    const result = validate('80028061-0');
+
+    expect(result.isValid && result.compact).toEqual('800280610');
+  });
+
+  it('validate:8765432-6', () => {
+    const result = validate('8765432-6');
+
+    expect(result.isValid && result.compact).toEqual('87654326');
+  });
+
+  it('validate:2660-3', () => {
+    const result = validate('2660-3');
+
+    expect(result.isValid && result.compact).toEqual('26603');
+  });
+
+  it('validate:660-3', () => {
+    const result = validate('660-3');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:2660-4', () => {
+    const result = validate('2660-4');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/py/ruc.ts

@@ -0,0 +1,93 @@
+/**
+ *
+ * Paraguay RUC numbers
+ *
+ * RUC number (Registro Único del Contribuyentes, Paraguay tax number).
+ *
+ * The Registro Único del Contribuyente (RUC) is the unique taxpayer registry
+ * that maintains identification numbers for all persons (national or foreign)
+ * and legal entities in Paraguay.
+ *
+ * The RUC number for legal entities consists of 8 digits starting after
+ * 80000000. Number for residents and foreigners are up to 9 digits. The last
+ * digit is a check digit.
+ *
+ * Sources:
+ *   https://www.ruc.com.py/
+ *
+ * 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: 'Paraguay Tax Number',
+  localName: 'Registro Único del Contribuyentes',
+  abbreviation: 'RUC',
+  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.substr(0, value.length - 1)}-${value.substr(
+      value.length - 1,
+    )}`;
+  },
+
+  /**
+   * Check if the number is a valid RUC.
+   * 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 < 5 || value.length > 9) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [front, check] = strings.splitAt(value, value.length - 1);
+
+    const sum = front
+      .split('')
+      .reverse()
+      .map(x => parseInt(x, 10))
+      .reduce((acc, digit, idx) => acc + digit * (idx + 2), 0);
+
+    const digit = String((11 - (sum % 11)) % 10);
+
+    if (check !== digit) {
+      return { isValid: false, error: new exceptions.InvalidChecksum() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: parseInt(front, 10) < 80000000,
+      isCompany: front.length === 8 && parseInt(front, 10) > 80000000,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/ro/cif.spec.ts

@@ -0,0 +1,40 @@
+import { validate, format } from './cif';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('ro/cif', () => {
+  it('format:RO 185 472 90', () => {
+    const result = format('RO 185 472 90');
+
+    expect(result).toEqual('185 472 90');
+  });
+
+  it('validate:RO 185 472 90', () => {
+    const result = validate('RO 185 472 90');
+
+    expect(result.isValid && result.compact).toEqual('18547290');
+  });
+
+  it('validate:185 472 90', () => {
+    const result = validate('185 472 90');
+
+    expect(result.isValid && result.compact).toEqual('18547290');
+  });
+
+  it('validate:1630615123457', () => {
+    const result = validate('1630615123457');
+
+    expect(result.isValid && result.compact).toEqual('1630615123457');
+  });
+
+  it('validate:123456789012', () => {
+    const result = validate('123456789012');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:185 472 91', () => {
+    const result = validate('185 472 91');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/ro/cif.ts

@@ -0,0 +1,62 @@
+/**
+ * CIF (Cod de înregistrare în scopuri de TVA, Romanian VAT number).
+ *
+ * The Romanian CIF is used for VAT purposes and can be from 2 to 10 digits long.
+ *
+ * PERSON/ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { validate as cnpValidate } from './cnp';
+import { validate as cuiValidate, format as cuiFormat } from './cui';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -', 'RO');
+}
+
+const impl: Validator = {
+  name: 'Romanian VAT Number',
+  localName: 'Codul de Identificare Fiscală',
+  abbreviation: 'CIF',
+  compact(input: string): string {
+    const [value, err] = clean(input);
+
+    if (err) {
+      throw err;
+    }
+
+    return value;
+  },
+
+  format(input: string): string {
+    const [value] = clean(input);
+
+    return cuiFormat(value);
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (value.length === 13) {
+      // apparently a CNP can also be used (however, not all sources agree)
+      return cnpValidate(value);
+    }
+    if (value.length >= 2 && value.length <= 10) {
+      return cuiValidate(value);
+    }
+
+    return { isValid: false, error: new exceptions.InvalidLength() };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/ro/cnp.spec.ts

@@ -0,0 +1,50 @@
+import { validate, format } from './cnp';
+import {
+  InvalidLength,
+  InvalidChecksum,
+  InvalidComponent,
+} from '../exceptions';
+
+describe('ro/cnp', () => {
+  it('format:1630615123457', () => {
+    const result = format('1630615123457');
+
+    expect(result).toEqual('1630615123457');
+  });
+
+  it('validate:1630615123457', () => {
+    const result = validate('1630615123457');
+
+    expect(result.isValid && result.compact).toEqual('1630615123457');
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:1630615123458', () => {
+    const result = validate('1630615123458');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+
+  it('validate:0800101221142', () => {
+    const result = validate('0800101221142');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:0800101228842', () => {
+    const result = validate('0800101228842');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:1632215123457', () => {
+    const result = validate('1632215123457');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+});