stdnum 1.10.0 → 1.10.2

package/src/dk/cvr.ts

@@ -0,0 +1,81 @@
+/**
+ * CVR (Momsregistreringsnummer, Danish VAT number).
+ *
+ * The CVR (Momsregistreringsnummer, VAT) is an 8 digit number with a
+ * straightforward check mechanism
+ *
+ * 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> {
+  const [value, err] = strings.cleanUnicode(input, ' -');
+  if (err !== null) {
+    return [value, err];
+  }
+  if (value.startsWith('DK')) {
+    return [value.substr(2), null];
+  }
+
+  return [value, null];
+}
+
+const impl: Validator = {
+  name: 'Danish VAT Number',
+  localName: 'Momsregistreringsnummer',
+  abbreviation: 'CVR',
+
+  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 !== 8) {
+      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: 11,
+      weights: [2, 7, 6, 5, 4, 3, 2, 1],
+    });
+    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/dk/index.ts

@@ -0,0 +1,2 @@
+export * as cpr from './cpr';
+export * as cvr from './cvr';

package/src/do/cedula.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './cedula';
+import { InvalidLength, InvalidFormat, InvalidChecksum } from '../exceptions';
+
+describe('do/cedula', () => {
+  it('format:00113918205', () => {
+    const result = format('00113918205');
+
+    expect(result).toEqual('001-1391820-5');
+  });
+
+  it('validate:00113918205', () => {
+    const result = validate('00113918205');
+
+    expect(result.isValid && result.compact).toEqual('00113918205');
+  });
+
+  it('validate:0011391820Q', () => {
+    const result = validate('0011391820Q');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:001139182', () => {
+    const result = validate('001139182');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:00113918204', () => {
+    const result = validate('00113918204');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/do/cedula.ts

@@ -0,0 +1,67 @@
+/**
+ * Cedula (Dominican Republic national identification number).
+ *
+ * A cedula is is an 11-digit number issues by the Dominican Republic government
+ * to citizens or residents for identification purposes.
+ *
+ * Source
+ *
+ * VAT 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: 'Dominican Republic National Identification Number',
+  localName: 'Cedula',
+  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, 10).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 (!strings.isdigits(value.substr(1))) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (!luhnChecksumValidate(value)) {
+      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/do/index.ts

@@ -0,0 +1,3 @@
+export * as cedula from './cedula';
+export * as ncf from './ncf';
+export * as rnc from './rnc';

package/src/do/ncf.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './ncf';
+import { InvalidLength, InvalidComponent } from '../exceptions';
+
+describe('do/ncf', () => {
+  it('format:E31 000000 0005', () => {
+    const result = format('E31 000000 0005');
+
+    expect(result).toEqual('E310000000005');
+  });
+
+  it('validate:E310000000005', () => {
+    const result = validate('E310000000005');
+
+    expect(result.isValid && result.compact).toEqual('E310000000005');
+  });
+
+  it('validate:B0100000005', () => {
+    const result = validate('B0100000005');
+
+    expect(result.isValid && result.compact).toEqual('B0100000005');
+  });
+
+  it('validate:Z0100000005', () => {
+    const result = validate('Z0100000005');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:Z0100', () => {
+    const result = validate('Z0100');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+});

package/src/do/ncf.ts

@@ -0,0 +1,133 @@
+/**
+ * NCF (Números de Comprobante Fiscal, Dominican Republic receipt number).
+ *
+ * The NCF is used to number invoices and other documents for the purpose of tax
+ * filing. The e-CF (Comprobante Fiscal Electrónico) is used together with a
+ * digital certificate for the same purpose. The number is either 19, 11 or 13
+ * (e-CF) digits long.
+ *
+ * The 19 digit number starts wit a letter (A or P) to indicate that the number
+ * was assigned by the taxpayer or the DGII, followed a 2-digit business unit
+ * number, a 3-digit location number, a 3-digit mechanism identifier, a 2-digit
+ * document type and a 8-digit serial number.
+ *
+ * The 11 digit number always starts with a B followed a 2-digit document type
+ * and a 7-digit serial number.
+ *
+ * The 13 digit e-CF starts with an E followed a 2-digit document type and an
+ * 8-digit serial number.
+ *
+ * Source
+ *    https://www.dgii.gov.do/
+ *    https://dgii.gov.do/workshopProveedoresTI-eCE/Documents/Norma05-19.pdf
+ *    https://dgii.gov.do/cicloContribuyente/facturacion/comprobantesFiscales/Paginas/tiposComprobantes.aspx
+ *
+ * VAT ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+
+const ncfTypes = [
+  '01', // invoices for fiscal declaration (or tax reporting)
+  '02', // invoices for final consumer
+  '03', // debit note
+  '04', // credit note (refunds)
+  '11', // informal supplier invoices (purchases)
+  '12', // single income invoices
+  '13', // minor expenses invoices (purchases)
+  '14', // invoices for special customers (tourists, free zones)
+  '15', // invoices for the government
+  '16', // invoices for export
+  '17', // invoices for payments abroad
+];
+
+const ecfTypes = [
+  '31', // invoices for fiscal declaration (or tax reporting)
+  '32', // invoices for final consumer
+  '33', // debit note
+  '34', // credit note (refunds)
+  '41', // supplier invoices (purchases)
+  '43', // minor expenses invoices (purchases)
+  '44', // invoices for special customers (tourists, free zones)
+  '45', // invoices for the government
+  '46', // invoices for exports
+  '47', // invoices for foreign payments
+];
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' ');
+}
+
+const impl: Validator = {
+  name: 'Dominican Republic Receipt Number',
+  localName: 'Números de Comprobante Fiscal',
+  abbreviation: 'NCF',
+  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 === 13) {
+      if (!value.startsWith('E')) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (!strings.isdigits(value.substr(1))) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (!ecfTypes.includes(value.substr(1, 2))) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+    } else if (value.length === 11) {
+      if (!value.startsWith('B')) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (!strings.isdigits(value.substr(1))) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (!ncfTypes.includes(value.substr(1, 2))) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+    } else if (value.length === 19) {
+      if (!value.startsWith('AP')) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (!strings.isdigits(value.substr(2))) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+      if (!ncfTypes.includes(value.substr(9, 2))) {
+        return { isValid: false, error: new exceptions.InvalidComponent() };
+      }
+    } 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/do/rnc.spec.ts

@@ -0,0 +1,40 @@
+import { validate, format } from './rnc';
+import { InvalidLength, InvalidChecksum, InvalidFormat } from '../exceptions';
+
+describe('do/rnc', () => {
+  it('format:101850043', () => {
+    const result = format('101850043');
+
+    expect(result).toEqual('1-01-85004-3');
+  });
+
+  it('validate:1-01-85004-3', () => {
+    const result = validate('1-01-85004-3');
+
+    expect(result.isValid && result.compact).toEqual('101850043');
+  });
+
+  it('validate:401505967', () => {
+    const result = validate('401505967');
+
+    expect(result.isValid && result.compact).toEqual('401505967');
+  });
+
+  it('validate:1018A0043', () => {
+    const result = validate('1018A0043');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:10185004', () => {
+    const result = validate('10185004');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:101850042', () => {
+    const result = validate('101850042');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/do/rnc.ts

@@ -0,0 +1,74 @@
+/**
+ * RNC (Registro Nacional del Contribuyente, Dominican Republic tax number).
+ *
+ * The RNC is the Dominican Republic taxpayer registration number for
+ * institutions. The number consists of 9 digits.
+ *
+ * Source
+ *
+ * TAX 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, ' -');
+}
+
+const impl: Validator = {
+  name: 'Dominican Republic Tax Number',
+  localName: 'Registro Nacional del Contribuyente',
+  abbreviation: 'RNC',
+  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, -1).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() };
+    }
+
+    const [front, check] = strings.splitAt(value, 8);
+
+    const sum = weightedSum(front, {
+      weights: [7, 9, 8, 6, 5, 4, 3, 2],
+      modulus: 11,
+    });
+
+    if (String(((10 - sum) % 9) + 1) !== 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/dz/index.ts

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

package/src/dz/nif.spec.ts

@@ -0,0 +1,39 @@
+import { validate, format } from './nif';
+import { InvalidLength, InvalidFormat } from '../exceptions';
+
+describe('dz/nif', () => {
+  it('format:000 216 001 808 337 13010', () => {
+    const result = format('000 216 001 808 337 13010');
+
+    expect(result).toEqual('00021600180833713010');
+  });
+
+  it('fvalidate:000 216 001 808 337 13010', () => {
+    const result = validate('000 216 001 808 337 13010');
+
+    expect(result.isValid && result.compact).toEqual('00021600180833713010');
+  });
+
+  test.each([
+    '416001000000007',
+    '408 020 000 150 039',
+    '41201600000606600001',
+    '000 216 001 808 337 13010',
+  ])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate:X1600100000000V', () => {
+    const result = validate('X1600100000000V');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:41600100000000', () => {
+    const result = validate('41600100000000');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+});

package/src/dz/nif.ts

@@ -0,0 +1,80 @@
+/**
+ * NIF, sometimes N.I.F. (Numéro d'Identification Fiscale, Algeria tax number).
+ *
+ * The NIF was adopted by the Algerian tax authorities on 2006, replacing the NIS
+ * number.
+ *
+ * The NIF applies to physical persons, legal persons, legal entities,
+ * administrative entities, local branches for foreign companies, associations,
+ * professional organisations, etc.
+ *
+ * The NIF consists of 15 digits, but sometimes it can be 20 digits long in order
+ * to represent branches or secondary establishments.
+ *
+ * Source
+ *   http://www.jecreemonentreprise.dz/index.php?option=com_content&view=article&id=612&Itemid=463&lang=fr
+ *   https://www.mf.gov.dz/index.php/fr/fiscalite
+ *   https://cnrcinfo.cnrc.dz/numero-didentification-fiscale-nif/
+ *   https://nifenligne.mfdgi.gov.dz/
+ *   http://nif.mfdgi.gov.dz/nif.asp
+ *
+ * ENTITY/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 validRe = /^[PCGQV]{1}00[A-Z0-9]{8}$/;
+
+// const ALPHABET = '0123456789X';
+
+const impl: Validator = {
+  name: 'Algeria tax number',
+  localName: "Numéro d'Identification Fiscale",
+  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 value;
+  },
+
+  validate(input: string): ValidateReturn {
+    const [value, error] = clean(input);
+
+    if (error) {
+      return { isValid: false, error };
+    }
+    if (value.length !== 15 && value.length !== 20) {
+      return { isValid: false, error: new exceptions.InvalidLength() };
+    }
+    if (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    return {
+      isValid: true,
+      compact: value,
+      isIndividual: false,
+      isCompany: false,
+    };
+  },
+};
+
+export const { name, localName, abbreviation, validate, format, compact } =
+  impl;

package/src/ec/ci.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './ci';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('ec/ci', () => {
+  it('format:1714307103', () => {
+    const result = format('1714307103');
+
+    expect(result).toEqual('171430710-3');
+  });
+
+  it('validate:171430710-3', () => {
+    const result = validate('171430710-3');
+
+    expect(result.isValid && result.compact).toEqual('1714307103');
+  });
+
+  it('validate:171430710', () => {
+    const result = validate('171430710');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:1714307104', () => {
+    const result = validate('1714307104');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});