stdnum 1.9.16 → 1.10.1

package/src/il/hp.ts

@@ -0,0 +1,75 @@
+/**
+ * Company Number (מספר חברה, or short ח.פ. Israeli company number).
+ *
+ * It consists of nine digits and includes a check digit. For companies
+ * the first digit is a 5. The first two digits identify the type of
+ * company.
+ *
+ * Source
+ *   https://he.wikipedia.org/wiki/תאגיד#מספר_רישום_התאגיד
+ *   https://www.oecd.org/tax/automatic-exchange/crs-implementation-and-assistance/tax-identification-numbers/Israel-TIN.pdf
+ *   https://wiki.scn.sap.com/wiki/display/CRM/Israel
+ *
+ * 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: 'Israeli Company Number',
+  localName: 'מספר חברה',
+  abbreviation: 'ח.פ.',
+  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)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (value[0] !== '5') {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    if (!luhnChecksumValidate(value)) {
+      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/il/idnr.spec.ts

@@ -0,0 +1,28 @@
+import { validate, format } from './idnr';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('il/idnr', () => {
+  it('format:39337423', () => {
+    const result = format('39337423');
+
+    expect(result).toEqual('3933742-3');
+  });
+
+  it('validate:3933742-3', () => {
+    const result = validate('3933742-3');
+
+    expect(result.isValid && result.compact).toEqual('39337423');
+  });
+
+  it('validate:3933742999', () => {
+    const result = validate('3933742999');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:3933742-2', () => {
+    const result = validate('3933742-2');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/il/idnr.ts

@@ -0,0 +1,70 @@
+/**
+ * Identity Number (Mispar Zehut, מספר זהות, Israeli identity number).
+ *
+* The identity number (Mispar Zehut, מספר זהות) is issued at birth to Israeli
+* citizens. The number consists of nine digits and includes a check digit.
+
+* Source
+*   https://en.wikipedia.org/wiki/National_identification_number#Israel
+*   https://en.wikipedia.org/wiki/Israeli_identity_card
+*   https://he.wikipedia.org/wiki/מספר_זהות_(ישראל)
+ *
+ * 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: 'Israeli Identify Number',
+  localName: 'Mispar Zehut, מספר זהות',
+  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).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.padStart(9, '0'))) {
+      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/il/index.ts

@@ -0,0 +1,2 @@
+export * as hp from './hp';
+export * as idnr from './idnr';

package/src/in/aadhaar.spec.ts

@@ -0,0 +1,40 @@
+import { validate, format } from './aadhaar';
+import { InvalidLength, InvalidChecksum, InvalidFormat } from '../exceptions';
+
+describe('in/aadhaar', () => {
+  it('format:234123412346', () => {
+    const result = format('234123412346');
+
+    expect(result).toEqual('2341 2341 2346');
+  });
+
+  it('validate:234123412346', () => {
+    const result = validate('234123412346');
+
+    expect(result.isValid && result.compact).toEqual('234123412346');
+  });
+
+  it('validate:123412341234', () => {
+    const result = validate('123412341234');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:222222222222', () => {
+    const result = validate('222222222222');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:12345678', () => {
+    const result = validate('12345678');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:234123412347', () => {
+    const result = validate('234123412347');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/in/aadhaar.ts

@@ -0,0 +1,85 @@
+/**
+ * Aadhaar (Indian digital resident personal identity number)
+ *
+ * Aadhaar is a 12 digit identification number that can be obtained by Indian
+ * citizens, non-residents passport holders of India and resident foreign
+ * nationals. The number is issued by the Unique Identification Authority of
+ * India (UIDAI).
+ *
+ * Aadhaar is made up of 12 digits where the last digits is a check digit
+ * calculated using the Verhoeff algorithm. The numbers are generated in a
+ * random, non-repeating sequence and do not begin with 0 or 1.
+ *
+ * Aadhaar is a 12 digit unique identity number issued to all Indian residents.
+ * The number is assigned by the Unique Identification Authority of India
+ * (UIDAI).
+ *
+ * Source
+ *   https://web.archive.org/web/20140611025606/http://uidai.gov.in/UID_PDF/Working_Papers/A_UID_Numbering_Scheme.pdf
+ *   https://en.wikipedia.org/wiki/Aadhaar
+ *
+ * PERSON
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { verhoeffValidate } from '../util/checksum';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const impl: Validator = {
+  name: 'Indian Digital Resident Personal Identity Number',
+  localName: 'Aadhaar',
+  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, 4, 8).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 (!strings.isdigits(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (value[0] === '0' || value[0] === '1') {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+    if (value.split('').reverse().join('') === value) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    if (!verhoeffValidate(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/in/epic.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './epic';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('in/epic', () => {
+  it('format:WKH1186253', () => {
+    const result = format('WKH1186253');
+
+    expect(result).toEqual('WKH1186253');
+  });
+
+  it('fvalidate:WKH1186253', () => {
+    const result = validate('WKH1186253');
+
+    expect(result.isValid && result.compact).toEqual('WKH1186253');
+  });
+
+  test.each(['WKH1186253'])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate:WKH118625', () => {
+    const result = validate('WKH118625');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:WKH1186254', () => {
+    const result = validate('WKH1186254');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/in/epic.ts

@@ -0,0 +1,85 @@
+/**
+ * EPIC (Electoral Photo Identity Card, Indian Voter ID).
+ *
+ * The Electoral Photo Identity Card (EPIC) is an identity document issued by
+ * the Election Commission of India (ECI) only to the India citizens who have
+ * reached the age of 18.
+ *
+ * Each EPIC contains an unique 10 digit alphanumeric identifier known as EPIC
+ * number or Voter ID number.
+ *
+ * Every EPIC number begins with a Functional Unique Serial Number (FUSN), a 3
+ * letter unique identifier for each Assembly Constituency. FUSN is followed by
+ * a 6 digit serial number and 1 check digit of the serial number calculated
+ * using Luhn algorithm.
+ *
+ * Source
+ *   https://en.wikipedia.org/wiki/Voter_ID_(India)
+ *   https://www.kotaksecurities.com/ksweb/voter-id/serial-number-in-elctoral-roll
+ *
+ * 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 validRe = /^[A-Z]{3}[0-9]{7}$/;
+
+const impl: Validator = {
+  name: 'Electoral Photo Identity Card',
+  localName: '',
+  abbreviation: 'EPIC',
+
+  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 (!validRe.test(value)) {
+      return { isValid: false, error: new exceptions.InvalidFormat() };
+    }
+
+    const [, front] = strings.splitAt(value, 3);
+
+    if (!luhnChecksumValidate(front)) {
+      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/in/gstin.spec.ts

@@ -0,0 +1,34 @@
+import { validate, format } from './gstin';
+import { InvalidLength, InvalidChecksum } from '../exceptions';
+
+describe('in/gstin', () => {
+  it('format:27AAPFU0939F1ZV', () => {
+    const result = format('27AAPFU0939F1ZV');
+
+    expect(result).toEqual('27AAPFU0939F1ZV');
+  });
+
+  it('fvalidate:27AAPFU0939F1ZV', () => {
+    const result = validate('27AAPFU0939F1ZV');
+
+    expect(result.isValid && result.compact).toEqual('27AAPFU0939F1ZV');
+  });
+
+  test.each(['27AAPFU0939F1ZV', '29AAGCB7383J1Z4'])('validate:%s', value => {
+    const result = validate(value);
+
+    expect(result.isValid).toEqual(true);
+  });
+
+  it('validate:27AAPFU0939F1Z', () => {
+    const result = validate('27AAPFU0939F1Z');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  it('validate:27AAPFU0939F1Z0', () => {
+    const result = validate('27AAPFU0939F1Z0');
+
+    expect(result.error).toBeInstanceOf(InvalidChecksum);
+  });
+});

package/src/in/gstin.ts

@@ -0,0 +1,156 @@
+/**
+ * GSTIN (Goods and Services Tax identification number, Indian VAT number).
+ *
+ * The Goods and Services Tax identification number (GSTIN) is a 15 digit unique
+ * identifier assigned to all business entities in India registered under the
+ * Goods and Services Tax (GST) Act, 2017.
+ *
+ * Each GSTIN begins with a 2 digit state code, the next 10 characters are the
+ * holder's PAN, the 13th character is an alphanumeric digit that represents the
+ * number of GSTIN registrations made in a state or union territory for same the
+ * PAN, the 14th character is 'Z' and the last character is an alphanumeric
+ * check digit calculated using Luhn mod 36 algorithm.
+ *
+ * DESCRIPTION
+ *
+ * Source
+ *   https://bajajfinserv.in/insights/what-is-goods-and-service-tax-identification-number
+ *   https://ddvat.gov.in/docs/List%20of%20State%20Code.pdf
+ *   https://en.wikipedia.org/wiki/Goods_and_Services_Tax_(India)
+ *
+ * ENTITY
+ */
+
+import * as exceptions from '../exceptions';
+import { strings } from '../util';
+import { Validator, ValidateReturn } from '../types';
+import { validate as panValidate } from './pan';
+
+function clean(input: string): ReturnType<typeof strings.cleanUnicode> {
+  return strings.cleanUnicode(input, ' -');
+}
+
+const validRe = /^[0-9]{2}[A-Z]{5}[0-9]{4}[A-Z][0-9A-Z]{3}$/;
+
+const ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+const STATE_CODES: Record<string, string> = {
+  '01': 'Jammu and Kashmir',
+  '02': 'Himachal Pradesh',
+  '03': 'Punjab',
+  '04': 'Chandigarh',
+  '05': 'Uttarakhand',
+  '06': 'Haryana',
+  '07': 'Delhi',
+  '08': 'Rajasthan',
+  '09': 'Uttar Pradesh',
+  '10': 'Bihar',
+  '11': 'Sikkim',
+  '12': 'Arunachal Pradesh',
+  '13': 'Nagaland',
+  '14': 'Manipur',
+  '15': 'Mizoram',
+  '16': 'Tripura',
+  '17': 'Meghalaya',
+  '18': 'Assam',
+  '19': 'West Bengal',
+  '20': 'Jharkhand',
+  '21': 'Orissa',
+  '22': 'Chattisgarh',
+  '23': 'Madhya Pradesh',
+  '24': 'Gujarat',
+  '25': 'Daman and Diu',
+  '26': 'Dadar and Nagar Haveli',
+  '27': 'Maharashtra',
+  '28': 'Andhra Pradesh',
+  '29': 'Karnataka',
+  '30': 'Goa',
+  '31': 'Lakshadweep',
+  '32': 'Kerala',
+  '33': 'Tamil Nadu',
+  '34': 'Puducherry',
+  '35': 'Anadaman and Nicobar Islands',
+  '36': 'Telangana',
+  '37': 'Andhra Pradesh (New)',
+};
+
+const VALID_STATE_CODES = Object.keys(STATE_CODES);
+
+const impl: Validator = {
+  name: 'NAME',
+  localName: 'NAME',
+  abbreviation: 'GSTIN',
+
+  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() };
+    }
+
+    const [state, panValue] = strings.splitAt(value, 2, 12);
+    if (!VALID_STATE_CODES.includes(state)) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (value[12] === '0' || value[13] !== 'Z') {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+    if (!panValidate(panValue).isValid) {
+      return { isValid: false, error: new exceptions.InvalidComponent() };
+    }
+
+    const [first, check] = strings.splitAt(value, -1);
+
+    const sum = first
+      .split('')
+      .map((char, index) => {
+        const product = ALPHABET.indexOf(char) * (index % 2 !== 0 ? 2 : 1);
+
+        return (
+          Math.floor(product / ALPHABET.length) + (product % ALPHABET.length)
+        );
+      })
+      .reduce((prev, current) => {
+        return prev + current;
+      });
+
+    const checksum =
+      (ALPHABET.length - (sum % ALPHABET.length)) % ALPHABET.length;
+    if (ALPHABET[checksum] !== 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/in/index.ts

@@ -0,0 +1,4 @@
+export * as aadhaar from './aadhaar';
+export * as pan from './pan';
+export * as epic from './epic';
+export * as gstin from './gstin';

package/src/in/pan.spec.ts

@@ -0,0 +1,40 @@
+import { validate, format } from './pan';
+import { InvalidLength, InvalidFormat, InvalidComponent } from '../exceptions';
+
+describe('in/pan', () => {
+  it('format:AAPPV8261K', () => {
+    const result = format('AAPPV8261K');
+
+    expect(result).toEqual('AAPPV8261K');
+  });
+
+  it('validate:ACUPA7085R', () => {
+    const result = validate('ACUPA7085R');
+
+    expect(result.isValid && result.compact).toEqual('ACUPA7085R');
+  });
+
+  it('validate:ABMPA32111', () => {
+    const result = validate('ABMPA32111');
+
+    expect(result.error).toBeInstanceOf(InvalidFormat);
+  });
+
+  it('validate:ABMXA3211G', () => {
+    const result = validate('ABMXA3211G');
+
+    expect(result.error).toBeInstanceOf(InvalidComponent);
+  });
+
+  it('validate:234123412347', () => {
+    const result = validate('234123412347');
+
+    expect(result.error).toBeInstanceOf(InvalidLength);
+  });
+
+  // it('validate:2449/494/16/0', () => {
+  //   const result = validate('2449/494/16/0');
+
+  //   expect(result.error).toBeInstanceOf(InvalidChecksum);
+  // });
+});