"env": {

"commonjs": true,

"es6": true,

"node": true

},

"extends": "eslint:recommended",

"globals": {

"Atomics": "readonly",

"SharedArrayBuffer": "readonly"

},

"parserOptions": {

"ecmaVersion": 2018

},

"rules": {

}

Maps a given index to a unique valid CSS. Uses the smallest class names possible, with lower indices having smaller class names.

`cssClassGenerator(index, prefix = '')` -> string

Class names are not random - a given index will always return the same class name.

The prefix option gives more optimal class names than `prefix + cssClassGenerator(index)`. It never returns the prefix alone - it's always appended with something. In development, it will `console.warn` if prefix is not a valid class name (unless the prefix is `-`).

Be careful for high values (`2 ** 30` and above), as JavaScript integer vs float quirks can happen.

const cssClassGenerator = require("css-class-generator");

cssClassGenerator(0); // 'a'

cssClassGenerator(1); // 'b'

cssClassGenerator(52); // '_'

cssClassGenerator(53); // '-a'

cssClassGenerator(10000); // K3c

cssClassGenerator(1e9); // CVJ2gb

cssClassGenerator(0, "hello"); // 'helloa'

cssClassGenerator(1, "hello"); // 'hellob'

const chars =

"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789-";

const numChars = 64; // chars.length

const validFirstChars = 53; // chars.indexOf("_") + 1

const twoCharPermutations = validFirstChars + validFirstChars * numChars;

module.exports = (index, prefix) => {

if (process.env.NODE_ENV !== "production") {

const validIdent = /^-?[_a-z][_a-z0-9-]*$/i;

if (prefix != null && prefix !== "-" && !validIdent.test(prefix)) {

// eslint-disable-next-line

console.warn(`Expected prefix (${prefix}) to be a valid css class name`);

}

}

let i;

let current;

if (prefix == null || prefix === "") {

if (index < validFirstChars) return chars[index];

const _index = index - validFirstChars;

const c = _index % twoCharPermutations;

if (c < validFirstChars) {

current = "-" + chars[c];

} else {

const _c = c - validFirstChars;

const c0 = _c % validFirstChars;

const c1 = (_c / validFirstChars) | 0;

current = chars[c0] + chars[c1];

}

i = (_index / twoCharPermutations) | 0;

} else if (prefix === "-") {

const c = index % validFirstChars;

current = "-" + chars[c];

i = (index / validFirstChars) | 0;

} else {

if (index === 0) return prefix + chars[0];

current = prefix;

i = index;

}

let base = numChars;

while (i > 0) {

const c = i % numChars;

current += chars[c];

i = (i / numChars) | 0;

base = base * numChars;

}

return current;

"version": "2.0.0",

"main": "index.js",

"eslint": "^5.16.0",

"prettier": "^1.17.0"

const assert = require("assert");

const generate = require(".");

const runTests = ({ num = 1e4, prefix } = {}) => {

const validIdent = /^-?[_a-z][_a-z0-9-]*$/i;

let last = "";

const seen = new Set();

const changes = [];

for (let i = 0; i < num; i += 1) {

const next = generate(i, prefix);

assert(

prefix == null || next.startsWith(prefix),

`Expected ${next} to start with ${prefix}`

);

assert(validIdent.test(next), `Got invalid identifier for ${next} (${i})`);

assert(!next.includes("undefined"), `Got undefined for ${i}`);

const nextLength = next.length;

const lastLength = last.length;

assert(

nextLength >= lastLength,

`Invalid ordering for ${last} vs ${next} (${i})`

);

const hasSeen = seen.has(next);

const seenIndex = hasSeen ? Array.from(seen).indexOf(next) : -1;

assert(!hasSeen, `Already seen ${next} (${seenIndex} vs. ${i})`);

last = next;

if (i !== 0 && nextLength > lastLength) {

changes.push(i);

}

seen.add(next);

}

return [

`Passed tests with ${prefix ? `prefix "${prefix}"` : "no prefix"}`,

` Tested ${num} iterations`,

` Length transitions at: ${changes.join(", ")}`

].join("\n");

assert.equal(generate(0), "a");

assert.equal(generate(1), "b");

assert.equal(generate(0, "-"), "-a");

assert.equal(generate(1, "-"), "-b");

assert.equal(generate(0, "test"), "testa");

assert.equal(generate(1, "test"), "testb");

runTests({ num: 1e6 });

runTests({ num: 1e6, prefix: "-" });

runTests({ num: 1e6, prefix: "hello" });