@ck0/lib-enum

A tiny TypeScript helper for declaring string-literal-union enums with both an object map and a values list, derived from a single source of truth.

import { createEnum } from "@ck0/lib-enum";

const { object: Mode, list: ModeValues } = createEnum({
    dev: null,
    test: null,
    prod: null,
} as const);

// Mode.dev   === "dev"
// ModeValues === ["dev", "test", "prod"] (as const)

type Mode = (typeof Mode)[keyof typeof Mode];
// type Mode = "dev" | "test" | "prod"

Why this instead of enum?

TypeScript's native enum produces a runtime object with reverse mappings, doesn't pair cleanly with string-literal types, and doesn't give you a values list out of the box. createEnum gives you, from one declaration:

• A typed object (Mode.dev, Mode.test, …) for use in code.
• A readonly tuple of values (ModeValues) for runtime iteration, validation libraries (Zod's z.enum(ModeValues as [...]), etc.), and select dropdowns.
• A derived TypeScript type that's a plain string-literal union — no separate enum type to import.

Three ways to declare

1. Tuple of strings (simplest)

const { object: Architecture, list: ArchitectureValues } = createEnum([
    "amd64",
    "arm64",
] as const);

type Architecture = (typeof Architecture)[keyof typeof Architecture];

2. Object with null values (refactor-friendly)

When you want to rename a key later without touching every callsite:

const { object: Mode, list: ModeValues } = createEnum({
    dev: null,
    test: null,
    prod: null,
} as const);

3. Object with explicit string values

When the key and the runtime value should differ — e.g. the key is the symbolic name, the value is what's stored on disk:

const { object: Mode, list: ModeValues } = createEnum({
    dev: null,           // → "dev"
    test: "testing",     // → "testing"
    prod: undefined,     // → "prod"
} as const);

// Mode.dev  === "dev"
// Mode.test === "testing"
// Mode.prod === "prod"

API

• createEnum(input) — overloaded; dispatches to V1 (tuple) or V2 (record) based on input shape.
• createEnumV1(tuple) — explicit tuple form.
• createEnumV2(record) — explicit record form.

All return { object, list }. The types of both are precisely inferred from the input — no as casts needed at the use site.

Install

npm install @ck0/lib-enum
# or
pnpm add @ck0/lib-enum

License

MIT