Class Generator`Abstract`

Color sequence generators.

Index

Methods

cubehelix distinct gradient quantize scale spline

Methods

`Static`cubehelix

cubehelix(
    start?: number,
    rotations?: number,
    hue?: number,
    gamma?: number,
): (t: number) => Rgb
Generates a Cubehelix color scale function. Returns a function that takes t (0-1) and returns an Rgb color.
Parameters
- start: number = 300
  Start hue in degrees (0-360)
- rotations: number = -1.5
  Number of rotations (e.g., 1.5)
- hue: number = 1
  Saturation factor (0 = grayscale, 1 = default, >1 = super saturated)
- gamma: number = 1
  Gamma correction (1 = linear, <1 brighter, >1 darker)
Returns (t: number) => Rgb
The cubehelix function.
- Defined in functions/Generator.ts:86

`Static`distinct

distinct(count: number, opts?: Partial<RandomDistinctOptions>): Oklch[]
Generates a set of visually distinct colors. Ideal for charts, data visualization, and categorization. Uses OKLCH to ensure uniform perceptual brightness.
Parameters
- count: number
  The number of colors.
- Optionalopts: Partial<RandomDistinctOptions>
  The generation options.
Returns Oklch[]
The array of generated colors.
- Defined in functions/Generator.ts:138

`Static`gradient

gradient<C extends Color>(steps: number, c1: C, c2: C, mixer: Mixer<C>): C[]
Generates a list of colors forming a gradient.
Type Parameters
- C extends Color
Parameters
- steps: number
  The number of colors to generate.
- c1: C
  The first color.
- c2: C
  The second color.
- mixer: Mixer<C>
  The mixing method.
Returns C[]
The generated colors.
- Defined in functions/Generator.ts:196

`Static`quantize

quantize<C extends Color>(colors: C[], domain?: number[]): (t: number) => C
Creates a discrete scale (quantization). Unlike scale() which interpolates smoothly between colors, quantize() splits the domain into segments based on the number of colors passed and their weights.

Ideally suited for ColorBrewer palettes where distinct categories are preferred over gradients.
Type Parameters
- C extends Color
Parameters
- colors: C[]
  The array of colors to use as buckets.
- Optionaldomain: number[]
  The array of weights.
Returns (t: number) => C
A function that maps t (0-1) to one of the colors.
Example
```
const palette = Brewer.sequential.blues; // Array of 9 blues
const getBucket = Generator.quantize(palette);

getBucket(0.05) // Returns bucket 0 (Lightest blue)
getBucket(0.15) // Returns bucket 1
// ...
```
- Defined in functions/Generator.ts:254

`Static`scale

scale<C extends Color>(
    colors: C[],
    mixer: Mixer<C>,
    domain?: number[],
): (point: number) => C
Create a weighted scale of colors, passing through the given colors. If no weights are passed, all colors will have the same weight in range 0-1.
Type Parameters
- C extends Color
Parameters
- colors: C[]
  The colors to use.
- mixer: Mixer<C>
  The mixer function.
- Optionaldomain: number[]
  The array of weights.
Returns (point: number) => C
Throws
If the number of colors is less then 2, or the passed domain is invalid.
- Defined in functions/Generator.ts:304

`Static`spline

spline<C extends Color>(colors: C[]): (t: number) => C
Compute a spline interpolation between a set of colors. Uses Catmull-Rom spline on each channel, correctly handling Hue wrapping if present.
Type Parameters
- C extends Color
Parameters
- colors: C[]
  The list of colors (at least 1).
Returns (t: number) => C
The interpolation method.
- Defined in functions/Generator.ts:356