A single file JS library for Turkish ID numbers based around the work of github.com/ssg/TurkishId

tckn.js

/**
 * tckn - A simple JS library for handling Turkish ID Numbers
 * @license
 * Copyright 2021 İlteriş Yağıztegin Eroğlu (linuxgemini)
 * SPDX-License-Identifier: MIT
 */

"use strict";

class TCKN {
    /**
     * Verifies Turkish ID Number
     * @param {string} tckn Turkish ID Number
     * @returns {boolean}
     */
    static verifyTCKN(tckn) {
        const digitre = /^\d{11}$/;

        /** @param {string} n */
        const sumDigits = (n) => {
            return [...n].map(e=>parseInt(e)).reduce((a,b)=>a+b);
        };

        if (typeof(tckn) !== "string") throw TypeError("tckn is not a string");
        if (!digitre.test(tckn)) {
            throw RangeError(`tckn ${tckn} is not valid`);
        }

        const digits = tckn.split("");
        const d1 = parseInt(digits[0]);
        const d2 = parseInt(digits[1]);
        const d3 = parseInt(digits[2]);
        const d4 = parseInt(digits[3]);
        const d5 = parseInt(digits[4]);
        const d6 = parseInt(digits[5]);
        const d7 = parseInt(digits[6]);
        const d8 = parseInt(digits[7]);
        const d9 = parseInt(digits[8]);
        const d10 = parseInt(digits[9]);
        const d11 = parseInt(digits[10]);

        if (d1 <= 0) return false;

        let n = ((d1 + d3 + d5 + d7 + d9) * 7) - (d2 + d4 + d6 + d8);
        if (n < 0) n = n + 10;

        let d10calc = (n % 10);
        let newnumStr = `${tckn.slice(0,9)}${d10calc}`;
        let d11calc = (sumDigits(newnumStr) % 10);

        return (d10 === d10calc) && (d11 === d11calc);
    }

    /**
     * Generates an array of Turkish ID Numbers.
     * @param {number} amount Amount of Turkish ID Numbers to be generated.
     * @returns {string[]} tckn[]
     */
    static generateTCKN(amount = 1) {
        /**
         * Get random number between boundaries.
         * 
         * The maximum is exclusive and the minimum is inclusive.
         * @param {number} min
         * @param {number} max
         * @returns {number}
         */
        const getRandomInt = (min, max) => {
            min = Math.ceil(min);
            max = Math.floor(max);
            return Math.floor(Math.random() * (max - min) + min);
        };

        /**
         * @param {number} seed
         */
        const generateTCKNFromSeed = (seed) => {
            let d1 = Math.floor(seed / 100_000_000);
            let d2 = Math.floor(seed / 10_000_000) % 10;
            let d3 = Math.floor(seed / 1_000_000) % 10;
            let d4 = Math.floor(seed / 100_000) % 10;
            let d5 = Math.floor(seed / 10_000) % 10;
            let d6 = Math.floor(seed / 1000) % 10;
            let d7 = Math.floor(seed / 100) % 10;
            let d8 = Math.floor(seed / 10) % 10;
            let d9 = seed % 10;

            const oddSum = d1 + d3 + d5 + d7 + d9;
            const evenSum = d2 + d4 + d6 + d8;

            let n = (oddSum * 7) - evenSum;
            if (n < 0) n = n + 10;

            let d10 = n % 10;
            let d11 = (oddSum + evenSum + d10) % 10;

            return `${seed}${d10}${d11}`;
        };

        const returning = [];

        for (let i = 0; i < amount; i++) {
            let rnd = getRandomInt(100_000_000, 999_999_999);
            returning.push(generateTCKNFromSeed(rnd));
        }

        return returning;
    }
}

module.exports = TCKN;