nanoid 5.1.16: customAlphabet

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify nanoid.customAlphabet in pkg:npm/nanoid@5.1.16
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/nanoid@5.1.16
Demonstrate these symbols/APIs:
  - nanoid.customAlphabet

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:d25048ad12c42f5d31c40c504c76a861f3722f2eedf4fa4fdeb36a55e04f29db","contract":["customAlphabet returns an ID generator function configured with a custom character set and default size","customAlphabet generated generator produces strings of the specified length containing only characters from the alphabet","customAlphabet generated generator allows overriding the default size per invocation","customAlphabet generates unique IDs across multiple invocations"],"goal":"verify nanoid.customAlphabet in pkg:npm/nanoid@5.1.16","kind":"HOW","packages":["pkg:npm/nanoid@5.1.16"],"schemaVersion":1,"symbols":["nanoid.customAlphabet"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"esm","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/nanoid@5.1.16"],"schemaVersion":1,"subject":"pkg:npm/nanoid@5.1.16","symbols":["nanoid.customAlphabet"],"verifierAdapter":"node-typescript@1"}

import { customAlphabet } from 'nanoid';

/**
 * Creates an ID generator function with a custom alphabet and default size.
 * @param {string} alphabet - The set of allowed characters.
 * @param {number} [defaultSize=21] - Default length of generated IDs.
 * @returns {function(number=): string} ID generator function.
 */
export function createIdGenerator(alphabet, defaultSize = 21) {
  return customAlphabet(alphabet, defaultSize);
}

/**
 * Generates a single ID using a custom alphabet and specified size.
 * @param {string} alphabet - The set of allowed characters.
 * @param {number} [size=21] - Length of the generated ID.
 * @returns {string} Generated ID string.
 */
export function generateCustomId(alphabet, size = 21) {
  const nanoidCustom = customAlphabet(alphabet, size);
  return nanoidCustom();
}

export { customAlphabet };

{
  "name": "sample-nanoid-customalphabet",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-nanoid-customalphabet",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "nanoid": "5.1.16"
      }
    },
    "node_modules/nanoid": {
      "version": "5.1.16",
      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-5.1.16.tgz",
      "integrity": "sha512-kVrnsrJqMR8+oLJnGEmSWw9BivK5mt7H3FZatVRjrc5wGqFYuBxX1yG7+A7Gi5AefkX6t/oCkizcQgpu0cY1dQ==",
      "funding": [
        {
          "type": "github",
          "url": "https://github.com/sponsors/ai"
        }
      ],
      "license": "MIT",
      "bin": {
        "nanoid": "bin/nanoid.js"
      },
      "engines": {
        "node": "^18 || >=20"
      }
    }
  }
}

{
  "name": "sample-nanoid-customalphabet",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "description": "verify nanoid.customAlphabet in pkg:npm/nanoid@5.1.16",
  "main": "index.js",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "dependencies": {
    "nanoid": "5.1.16"
  },
  "license": "MIT-0"
}

{
  "schemaVersion": 1,
  "goal": "verify nanoid.customAlphabet in pkg:npm/nanoid@5.1.16",
  "kind": "HOW",
  "packages": [
    "pkg:npm/nanoid@5.1.16"
  ],
  "symbols": [
    "nanoid.customAlphabet"
  ]
}

import assert from 'node:assert';
import { customAlphabet } from 'nanoid';
import { createIdGenerator, generateCustomId } from '../index.js';

function testCustomAlphabetBasic() {
  const alphabet = '1234567890abcdef';
  const nanoidHex = customAlphabet(alphabet, 10);

  assert.strictEqual(typeof nanoidHex, 'function', 'customAlphabet should return a generator function');

  const id = nanoidHex();
  assert.strictEqual(typeof id, 'string', 'Generated ID should be a string');
  assert.strictEqual(id.length, 10, 'Generated ID length should match default size of 10');

  for (let i = 0; i < id.length; i++) {
    assert.ok(alphabet.includes(id[i]), `Character ${id[i]} must be in alphabet`);
  }
}

function testCustomAlphabetSizeOverride() {
  const alphabet = '0123456789';
  const nanoidDigits = customAlphabet(alphabet, 6);

  const defaultLenId = nanoidDigits();
  assert.strictEqual(defaultLenId.length, 6, 'Generated ID should use default size 6');
  assert.match(defaultLenId, /^[0-9]{6}$/, 'Generated ID should match numeric pattern');

  const customLenId = nanoidDigits(16);
  assert.strictEqual(customLenId.length, 16, 'Generated ID should use overridden size 16');
  assert.match(customLenId, /^[0-9]{16}$/, 'Generated ID should match numeric pattern');

  const shortId = nanoidDigits(1);
  assert.strictEqual(shortId.length, 1, 'Generated ID should respect size 1');
  assert.match(shortId, /^[0-9]$/, 'Generated ID should match numeric pattern');
}

function testCustomAlphabetUniqueness() {
  const alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789';
  const nanoidAlnum = customAlphabet(alphabet, 16);
  const seen = new Set();
  const iterations = 500;

  for (let i = 0; i < iterations; i++) {
    const id = nanoidAlnum();
    assert.strictEqual(id.length, 16, 'ID length must be 16');
    assert.strictEqual(seen.has(id), false, `Collision detected for ID: ${id}`);
    seen.add(id);
  }

  assert.strictEqual(seen.size, iterations, 'All generated IDs must be unique');
}

function testSingleCharacterAlphabet() {
  const nanoidOnlyA = customAlphabet('a', 5);
  const id = nanoidOnlyA();
  assert.strictEqual(id, 'aaaaa', 'Single character alphabet should return repeated character');
}

function testHelpers() {
  const generator = createIdGenerator('xyz', 4);
  const id1 = generator();
  assert.strictEqual(id1.length, 4, 'createIdGenerator should return working generator');
  assert.match(id1, /^[xyz]{4}$/, 'ID should contain only characters from alphabet');

  const id2 = generateCustomId('abc', 8);
  assert.strictEqual(id2.length, 8, 'generateCustomId should produce ID of requested length');
  assert.match(id2, /^[abc]{8}$/, 'ID should contain only characters from alphabet');
}

function runAll() {
  testCustomAlphabetBasic();
  testCustomAlphabetSizeOverride();
  testCustomAlphabetUniqueness();
  testSingleCharacterAlphabet();
  testHelpers();
  console.log('Contract tests passed successfully.');
}

try {
  runAll();
  process.exit(0);
} catch (err) {
  console.error('Contract test failed:', err);
  process.exit(1);
}