@sibevin/random-token/dist/index.js

A simple way to generate a random token.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.FRIENDLY_MASK = exports.DEFAULT_TOKEN_SIZE = exports.genf = exports.gen = void 0;
const DEFAULT_TOKEN_SIZE = 16;
exports.DEFAULT_TOKEN_SIZE = DEFAULT_TOKEN_SIZE;
const FRIENDLY_MASK = "1Ili0OoQDCcG96UuVvEFMN8B";
exports.FRIENDLY_MASK = FRIENDLY_MASK;
const NUM_SEEDS = "0123456789";
const HEX_SEEDS = `abcdef${NUM_SEEDS}`;
const ALPHABET_SEEDS = "abcdefghijklmnopqrstuvwxyz";
function generateRandomSeedPickFunc(seeds) {
    const sampleIndex = Math.floor(Math.random() * Math.floor(seeds.length));
    return seeds[sampleIndex];
}
function generateMixedCasedAlphabetSeeds(casing) {
    let seeds;
    if (!casing || casing === "m" || casing === "mixed") {
        seeds = `${ALPHABET_SEEDS}${ALPHABET_SEEDS.toUpperCase()}`;
    }
    else {
        seeds = ALPHABET_SEEDS;
    }
    return seeds;
}
function removeMaskedSeeds(seeds, mask) {
    const maskRegex = new RegExp(`[${mask}]*`, "g");
    return seeds.replace(maskRegex, "");
}
function filterSeedsWithFriendlyAndMask(seeds, friendly, mask) {
    let filteredSeeds = seeds;
    if (friendly) {
        filteredSeeds = removeMaskedSeeds(filteredSeeds, FRIENDLY_MASK);
    }
    if (typeof mask === "string") {
        filteredSeeds = removeMaskedSeeds(filteredSeeds, mask);
    }
    return filteredSeeds;
}
function throwInvalidParameterError(params) {
    if (params.checkResult) {
        const errorMsg = `Invalid Parameters: ${params.params}. ${params.message}`;
        throw new Error(errorMsg);
    }
}
const genToken = (params) => {
    let givenSeedType;
    switch (params.seed) {
        case 10:
        case 1:
        case "n":
        case "number":
            givenSeedType = "number";
            break;
        case 8:
        case "o":
        case "oct":
        case "octal":
            givenSeedType = "octal";
            break;
        case 2:
        case "b":
        case "binary":
            givenSeedType = "binary";
            break;
        case 16:
        case "h":
        case "hex":
        case "hexadecimal":
            givenSeedType = "hexadecimal";
            break;
        case "a":
        case "alphabet":
        case "l":
        case "letter":
            givenSeedType = "alphabet";
            break;
        default: {
            if (typeof params.seed === "string" && params.seed.length > 0) {
                givenSeedType = "customized";
            }
            else {
                givenSeedType = "random";
            }
        }
    }
    if (givenSeedType === "number" ||
        givenSeedType === "octal" ||
        givenSeedType === "binary") {
        throwInvalidParameterError({
            checkResult: params.casing !== undefined,
            params: "casing",
            message: `The casing is not supported with ${givenSeedType} seeds`,
        });
    }
    if (givenSeedType === "hexadecimal" || givenSeedType === "customized") {
        throwInvalidParameterError({
            checkResult: params.casing === "m" || params.casing === "mixed",
            params: "casing",
            message: `The mixed casing is not supported with ${givenSeedType} seeds.`,
        });
    }
    if (givenSeedType !== "alphabet" && givenSeedType !== "random") {
        throwInvalidParameterError({
            checkResult: params.friendly !== undefined,
            params: "friendly",
            message: 'The friendly mask is supported with alphabet or random-generated seeds (no "seed" is given) only.',
        });
    }
    let randomFunc;
    switch (givenSeedType) {
        case "number":
            randomFunc = () => Math.floor(Math.random() * Math.floor(10)).toString();
            break;
        case "octal":
            randomFunc = () => Math.floor(Math.random() * Math.floor(8)).toString();
            break;
        case "binary":
            randomFunc = () => Math.floor(Math.random() * Math.floor(2)).toString();
            break;
        case "hexadecimal":
            randomFunc = () => generateRandomSeedPickFunc(HEX_SEEDS);
            break;
        case "alphabet": {
            let seeds = generateMixedCasedAlphabetSeeds(params.casing);
            seeds = filterSeedsWithFriendlyAndMask(seeds, params.friendly, params.mask);
            randomFunc = () => generateRandomSeedPickFunc(seeds);
            break;
        }
        default: {
            let seeds = params.seed;
            if (givenSeedType === "random") {
                seeds = `${generateMixedCasedAlphabetSeeds(params.casing)}${NUM_SEEDS}`;
            }
            seeds = filterSeedsWithFriendlyAndMask(seeds, params.friendly, params.mask);
            randomFunc = () => generateRandomSeedPickFunc(seeds);
        }
    }
    let generatedToken = Array.from({ length: params.length || DEFAULT_TOKEN_SIZE }, randomFunc).join("");
    if (params.casing === "u" || params.casing === "upper") {
        generatedToken = generatedToken.toUpperCase();
    }
    else if (params.casing === "l" || params.casing === "lower") {
        generatedToken = generatedToken.toLowerCase();
    }
    return generatedToken;
};
function gen(params = {}) {
    return genToken(params);
}
exports.gen = gen;
function genf(params = {}) {
    return genToken(Object.assign({ friendly: true }, params));
}
exports.genf = genf;