@ankhorage/color-theory 0.0.2 → 0.0.3

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @ankhorage/color-theory
 
+## 0.0.3
+
+### Patch Changes
+
+- b769031: Point exports to dist/
+
 ## 0.0.2
 
 ### Patch Changes

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ankhorage/color-theory",
   "type": "module",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Standalone color theory, harmony, swatch, contrast, and theme color generation utilities.",
   "homepage": "https://github.com/ankhorage/color-theory#readme",
   "bugs": {
@@ -29,7 +29,6 @@
   },
   "files": [
     "dist",
-    "src",
     "package.json",
     "README.md",
     "CHANGELOG.md",
@@ -37,8 +36,8 @@
   ],
   "exports": {
     ".": {
-      "react-native": "./src/index.ts",
-      "browser": "./src/index.ts",
+      "react-native": "./dist/index.js",
+      "browser": "./dist/index.js",
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"

package/src/color-theory.test.ts

@@ -1,91 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-
-import {
-  COLOR_HARMONIES,
-  COLOR_SWATCH_BASE_STEP,
-  COLOR_SWATCH_STEPS,
-  generateColorSwatch,
-  generateHarmonyRoleColors,
-  generateNeutralSwatch,
-  generateThemeModeColors,
-  getReadableForeground,
-  parseHexColor,
-  parseHexColorOrThrow,
-} from './index';
-
-describe('color theory', () => {
-  it('parses valid hex colors and rejects invalid values', () => {
-    expect(parseHexColor('#3366ff')).toBe('#3366ff');
-    expect(parseHexColor('#3366FF')).toBe('#3366FF');
-    expect(parseHexColor('3366ff')).toBeNull();
-    expect(() => parseHexColorOrThrow('#12345')).toThrow();
-  });
-
-  it('generates harmony role colors with expected role counts', () => {
-    const primary = parseHexColorOrThrow('#3366ff');
-    const expectedRoleCount: Record<(typeof COLOR_HARMONIES)[number], number> = {
-      monochromatic: 1,
-      complementary: 2,
-      analogous: 3,
-      splitComplementary: 3,
-      triadic: 3,
-      tetradic: 4,
-    };
-
-    for (const harmony of COLOR_HARMONIES) {
-      const roleColors = generateHarmonyRoleColors(primary, harmony);
-      expect(roleColors.colors.length).toBe(expectedRoleCount[harmony]);
-      expect(roleColors.primary.hex).toBe(primary);
-      expect(roleColors.primary.source).toBe('selected');
-    }
-  });
-
-  it('generates 11-step swatches that preserve the base color at step 500', () => {
-    const base = parseHexColorOrThrow('#3366ff');
-    const { swatch, diagnostics } = generateColorSwatch(base);
-
-    expect(Object.keys(swatch).length).toBe(COLOR_SWATCH_STEPS.length);
-    expect(swatch[COLOR_SWATCH_BASE_STEP]).toBe(base);
-    expect(diagnostics.lightnessRange.max).toBeGreaterThanOrEqual(diagnostics.lightnessRange.min);
-  });
-
-  it('generates required neutral swatches from harmony role colors', () => {
-    const primary = parseHexColorOrThrow('#3366ff');
-    const roleColors = generateHarmonyRoleColors(primary, 'triadic');
-    const neutral = generateNeutralSwatch(roleColors);
-
-    expect(neutral.neutral[COLOR_SWATCH_BASE_STEP]).toBe(neutral.neutralKeyColor);
-    expect(neutral.diagnostics.lightnessRange.max).toBeGreaterThanOrEqual(
-      neutral.diagnostics.lightnessRange.min,
-    );
-  });
-
-  it('generates theme mode colors with one canonical swatch container', () => {
-    const generated = generateThemeModeColors({ primaryColor: '#3366ff', harmony: 'tetradic' });
-
-    expect(generated.harmonyRoleColors.primary.hex).toBe('#3366ff');
-    expect(generated.swatches.primary[COLOR_SWATCH_BASE_STEP]).toBe('#3366ff');
-    expect(generated.swatches.secondary?.[COLOR_SWATCH_BASE_STEP]).toBe(
-      generated.harmonyRoleColors.secondary?.hex,
-    );
-    expect(generated.swatches.tertiary?.[COLOR_SWATCH_BASE_STEP]).toBe(
-      generated.harmonyRoleColors.tertiary?.hex,
-    );
-    expect(generated.swatches.quaternary?.[COLOR_SWATCH_BASE_STEP]).toBe(
-      generated.harmonyRoleColors.quaternary?.hex,
-    );
-    expect(generated.swatches.neutral[COLOR_SWATCH_BASE_STEP]).toBe(
-      generated.neutral.neutralKeyColor,
-    );
-    expect(Object.hasOwn(generated, 'primary')).toBe(false);
-    expect(Object.hasOwn(generated, 'secondary')).toBe(false);
-  });
-
-  it('returns black or white readable foreground colors', () => {
-    const white = parseHexColorOrThrow('#FFFFFF');
-    const foreground = getReadableForeground(white);
-
-    expect(['#000000', '#FFFFFF']).toContain(foreground.foreground);
-    expect(foreground.contrast).toBeGreaterThan(0);
-  });
-});

package/src/contrast.ts

@@ -1,25 +0,0 @@
-import type { HexColor } from './hex';
-import { parseHexColorOrThrow } from './hex';
-import { contrastRatio } from './internal-culori';
-
-export interface ReadableForegroundResult {
-  foreground: HexColor;
-  contrast: number;
-}
-
-const BLACK = parseHexColorOrThrow('#000000');
-const WHITE = parseHexColorOrThrow('#FFFFFF');
-
-/***
-  Return the readable black or white foreground color with the stronger contrast against a background color.
-*/
-export function getReadableForeground(background: HexColor): ReadableForegroundResult {
-  const contrastOnBlack = contrastRatio(background, BLACK);
-  const contrastOnWhite = contrastRatio(background, WHITE);
-
-  if (contrastOnBlack >= contrastOnWhite) {
-    return { foreground: BLACK, contrast: contrastOnBlack };
-  }
-
-  return { foreground: WHITE, contrast: contrastOnWhite };
-}

package/src/culori-fn.ts

@@ -1 +0,0 @@
-export * from 'culori/fn';

package/src/culori.ts

@@ -1 +0,0 @@
-export * from 'culori';

package/src/harmony.ts

@@ -1,95 +0,0 @@
-import type { HexColor } from './hex';
-import { normalizeHueDegrees, oklchToHex, parseHexToOklch } from './internal-culori';
-
-export const COLOR_HARMONIES = [
-  'monochromatic',
-  'analogous',
-  'complementary',
-  'triadic',
-  'tetradic',
-  'splitComplementary',
-] as const;
-
-export type ColorHarmony = (typeof COLOR_HARMONIES)[number];
-
-export type GeneratedColorRole = 'primary' | 'secondary' | 'tertiary' | 'quaternary';
-
-export interface GeneratedHarmonyRoleColor {
-  role: GeneratedColorRole;
-  hex: HexColor;
-  hueDegrees: number;
-  source: 'selected' | 'generated';
-}
-
-export interface GeneratedHarmonyRoleColors {
-  harmony: ColorHarmony;
-  colors: readonly GeneratedHarmonyRoleColor[];
-  primary: GeneratedHarmonyRoleColor;
-  secondary?: GeneratedHarmonyRoleColor;
-  tertiary?: GeneratedHarmonyRoleColor;
-  quaternary?: GeneratedHarmonyRoleColor;
-}
-
-const ROLE_ORDER_BY_HARMONY: Record<ColorHarmony, readonly GeneratedColorRole[]> = {
-  monochromatic: ['primary'],
-  complementary: ['primary', 'secondary'],
-  analogous: ['primary', 'secondary', 'tertiary'],
-  splitComplementary: ['primary', 'secondary', 'tertiary'],
-  triadic: ['primary', 'secondary', 'tertiary'],
-  tetradic: ['primary', 'secondary', 'tertiary', 'quaternary'],
-};
-
-const OFFSETS_BY_HARMONY: Record<ColorHarmony, readonly number[]> = {
-  monochromatic: [0],
-  analogous: [0, -30, 30],
-  complementary: [0, 180],
-  splitComplementary: [0, 150, 210],
-  triadic: [0, 120, 240],
-  tetradic: [0, 90, 180, 270],
-};
-
-/***
-  Generate role-based harmony colors from a primary color and harmony strategy.
-*/
-export function generateHarmonyRoleColors(
-  primaryColor: HexColor,
-  harmony: ColorHarmony,
-): GeneratedHarmonyRoleColors {
-  const base = parseHexToOklch(primaryColor);
-  const roles = ROLE_ORDER_BY_HARMONY[harmony];
-  const offsets = OFFSETS_BY_HARMONY[harmony];
-  const baseHue = normalizeHueDegrees(base.h);
-
-  const colors: GeneratedHarmonyRoleColor[] = [];
-
-  for (let index = 0; index < roles.length; index++) {
-    const role = roles[index];
-    if (!role) continue;
-
-    const hueDegrees = normalizeHueDegrees(baseHue + (offsets[index] ?? 0));
-    colors.push({
-      role,
-      hex: role === 'primary' ? primaryColor : oklchToHex({ ...base, h: hueDegrees }),
-      hueDegrees,
-      source: role === 'primary' ? 'selected' : 'generated',
-    });
-  }
-
-  const primary = colors.find((color) => color.role === 'primary');
-  if (!primary) {
-    throw new Error('[color-theory] Expected generated harmony role colors to include primary.');
-  }
-
-  const secondary = colors.find((color) => color.role === 'secondary');
-  const tertiary = colors.find((color) => color.role === 'tertiary');
-  const quaternary = colors.find((color) => color.role === 'quaternary');
-
-  return {
-    harmony,
-    colors,
-    primary,
-    ...(secondary ? { secondary } : {}),
-    ...(tertiary ? { tertiary } : {}),
-    ...(quaternary ? { quaternary } : {}),
-  };
-}

package/src/hex.ts

@@ -1,38 +0,0 @@
-export type HexColor = string & { readonly __hexColorBrand: unique symbol };
-
-const HEX6_CASE_INSENSITIVE_REGEX = /^#[0-9a-fA-F]{6}$/;
-
-/***
-  Check whether a string is a valid six-digit hex color.
-*/
-export function isHexColor(value: string): value is HexColor {
-  return HEX6_CASE_INSENSITIVE_REGEX.test(value);
-}
-
-/***
-  Parse a string as a six-digit hex color and return null when it is invalid.
-*/
-export function parseHexColor(value: string): HexColor | null {
-  if (!HEX6_CASE_INSENSITIVE_REGEX.test(value)) return null;
-  return value as HexColor;
-}
-
-/***
-  Parse a string as a six-digit hex color or throw when it is invalid.
-*/
-export function parseHexColorOrThrow(value: string): HexColor {
-  const parsed = parseHexColor(value);
-  if (!parsed) {
-    throw new Error(`Invalid hex color (expected #RRGGBB or #rrggbb): ${JSON.stringify(value)}`);
-  }
-  return parsed;
-}
-
-/***
-  Assert that a string is a valid six-digit hex color.
-*/
-export function assertHexColor(value: string): asserts value is HexColor {
-  if (!isHexColor(value)) {
-    throw new Error(`Invalid hex color (expected #RRGGBB or #rrggbb): ${JSON.stringify(value)}`);
-  }
-}

package/src/index.ts

@@ -1,7 +0,0 @@
-export * from './contrast';
-export * from './harmony';
-export * from './hex';
-export * from './neutral';
-export * from './semantics';
-export * from './swatches';
-export * from './theme-colors';

package/src/internal-culori.ts

@@ -1,79 +0,0 @@
-import { converter, differenceEuclidean, formatHex, toGamut, wcagContrast } from 'culori';
-
-import type { HexColor } from './hex';
-import { parseHexColorOrThrow } from './hex';
-
-interface OklchColor {
-  mode: 'oklch';
-  l: number;
-  c: number;
-  h: number;
-  alpha?: number;
-}
-
-interface RgbColor {
-  mode: 'rgb';
-  r: number;
-  g: number;
-  b: number;
-  alpha?: number;
-}
-
-const toOklch = converter('oklch');
-const toRgbGamut = toGamut('rgb', 'oklch');
-const deltaE = differenceEuclidean('oklch');
-
-/***
-  Clamp a number to a finite minimum and maximum range.
-*/
-function clampNumber(value: number, min: number, max: number): number {
-  if (!Number.isFinite(value)) return min;
-  return Math.min(max, Math.max(min, value));
-}
-
-/***
-  Normalize hue degrees into the zero-to-three-sixty range.
-*/
-export function normalizeHueDegrees(hueDegrees: number): number {
-  const hue = ((hueDegrees % 360) + 360) % 360;
-  return hue === 360 ? 0 : hue;
-}
-
-/***
-  Convert a hex color into a normalized OKLCH color object.
-*/
-export function parseHexToOklch(hex: HexColor): OklchColor {
-  const color = toOklch(hex) as unknown as OklchColor | undefined;
-  if (color?.mode !== 'oklch') {
-    throw new Error(`Failed to convert hex to OKLCH: ${hex}`);
-  }
-
-  const l = clampNumber(color.l, 0, 1);
-  const c = clampNumber(color.c, 0, 0.4);
-  const h = normalizeHueDegrees(Number.isFinite(color.h) ? color.h : 0);
-
-  return { mode: 'oklch', l, c, h, alpha: color.alpha };
-}
-
-/***
-  Convert an OKLCH color object into an in-gamut hex color.
-*/
-export function oklchToHex(oklch: OklchColor): HexColor {
-  const gamutRgb = toRgbGamut(oklch) as unknown as RgbColor | undefined;
-  const hex = formatHex(gamutRgb ?? oklch);
-  return parseHexColorOrThrow(hex);
-}
-
-/***
-  Calculate the perceptual OKLCH distance between two OKLCH colors.
-*/
-export function deltaEoklch(a: OklchColor, b: OklchColor): number {
-  return deltaE(a, b);
-}
-
-/***
-  Calculate the WCAG contrast ratio between two color inputs.
-*/
-export function contrastRatio(colorA: string | object, colorB: string | object): number {
-  return wcagContrast(colorA as never, colorB as never);
-}

package/src/neutral.ts

@@ -1,77 +0,0 @@
-import type { ColorHarmony, GeneratedHarmonyRoleColors } from './harmony';
-import type { HexColor } from './hex';
-import { normalizeHueDegrees, oklchToHex, parseHexToOklch } from './internal-culori';
-import { type ColorSwatch, type ColorSwatchDiagnostics, generateColorSwatch } from './swatches';
-
-export const MIN_HUEFUL_CHROMA = 0.015;
-
-export interface NeutralSwatchResult {
-  neutralKeyColor: HexColor;
-  neutral: ColorSwatch;
-  diagnostics: ColorSwatchDiagnostics;
-}
-
-export interface GeneratedNeutralMetadata {
-  neutralKeyColor: HexColor;
-  diagnostics: ColorSwatchDiagnostics;
-}
-
-/***
-  Pick the harmony color that should tint the generated neutral swatch.
-*/
-function pickTintSourceHex(
-  roleColors: GeneratedHarmonyRoleColors,
-  harmony: ColorHarmony,
-): HexColor {
-  const byMapping: Partial<Record<ColorHarmony, HexColor | undefined>> = {
-    monochromatic: roleColors.primary.hex,
-    complementary: roleColors.secondary?.hex,
-    analogous: roleColors.tertiary?.hex,
-    splitComplementary: roleColors.tertiary?.hex,
-    triadic: roleColors.tertiary?.hex,
-    tetradic: roleColors.tertiary?.hex,
-  };
-
-  return (
-    byMapping[harmony] ??
-    roleColors.tertiary?.hex ??
-    roleColors.secondary?.hex ??
-    roleColors.primary.hex
-  );
-}
-
-/***
-  Clamp a number to a finite minimum and maximum range.
-*/
-function clampNumber(value: number, min: number, max: number): number {
-  if (!Number.isFinite(value)) return min;
-  return Math.min(max, Math.max(min, value));
-}
-
-/***
-  Generate a softly tinted neutral swatch from generated harmony role colors.
-*/
-export function generateNeutralSwatch(roleColors: GeneratedHarmonyRoleColors): NeutralSwatchResult {
-  const tintSourceHex = pickTintSourceHex(roleColors, roleColors.harmony);
-  const tintSource = parseHexToOklch(tintSourceHex);
-
-  const primary = parseHexToOklch(roleColors.primary.hex);
-
-  const preferGray = tintSource.c < MIN_HUEFUL_CHROMA;
-
-  const hue = roleColors.harmony === 'monochromatic' ? primary.h : tintSource.h;
-  const sourceChroma = roleColors.harmony === 'monochromatic' ? primary.c : tintSource.c;
-  const neutralHue = preferGray ? 0 : normalizeHueDegrees(hue);
-  const neutralChroma = preferGray ? 0 : clampNumber(sourceChroma * 0.06, 0.004, 0.012);
-
-  const neutralKeyColor = oklchToHex({
-    mode: 'oklch',
-    l: 0.6,
-    c: neutralChroma,
-    h: neutralHue,
-  });
-
-  const { swatch, diagnostics } = generateColorSwatch(neutralKeyColor);
-
-  return { neutralKeyColor, neutral: swatch, diagnostics };
-}

package/src/semantics.ts

@@ -1,60 +0,0 @@
-import type { GeneratedColorRole } from './harmony';
-import type { ColorSwatchStep } from './swatches';
-
-export type ThemeColorMode = 'light' | 'dark';
-
-export type SemanticColorToken =
-  | 'background'
-  | 'surface'
-  | 'surfaceRaised'
-  | 'border'
-  | 'divider'
-  | 'text'
-  | 'textMuted'
-  | 'disabledBg'
-  | 'disabledText'
-  | 'brand'
-  | 'brandEmphasis'
-  | 'action'
-  | 'actionEmphasis';
-
-export type SemanticColorRole = 'neutral' | GeneratedColorRole;
-
-export interface SemanticColorReference {
-  role: SemanticColorRole;
-  step: ColorSwatchStep;
-}
-
-export type SemanticColorReferenceMap = Record<SemanticColorToken, SemanticColorReference>;
-
-export const LIGHT_SEMANTIC_COLOR_REFERENCES: SemanticColorReferenceMap = {
-  background: { role: 'neutral', step: 50 },
-  surface: { role: 'neutral', step: 100 },
-  surfaceRaised: { role: 'neutral', step: 50 },
-  border: { role: 'neutral', step: 200 },
-  divider: { role: 'neutral', step: 200 },
-  text: { role: 'neutral', step: 900 },
-  textMuted: { role: 'neutral', step: 700 },
-  disabledBg: { role: 'neutral', step: 200 },
-  disabledText: { role: 'neutral', step: 500 },
-  brand: { role: 'primary', step: 600 },
-  brandEmphasis: { role: 'primary', step: 700 },
-  action: { role: 'primary', step: 600 },
-  actionEmphasis: { role: 'primary', step: 700 },
-};
-
-export const DARK_SEMANTIC_COLOR_REFERENCES: SemanticColorReferenceMap = {
-  background: { role: 'neutral', step: 950 },
-  surface: { role: 'neutral', step: 900 },
-  surfaceRaised: { role: 'neutral', step: 900 },
-  border: { role: 'neutral', step: 800 },
-  divider: { role: 'neutral', step: 800 },
-  text: { role: 'neutral', step: 50 },
-  textMuted: { role: 'neutral', step: 200 },
-  disabledBg: { role: 'neutral', step: 800 },
-  disabledText: { role: 'neutral', step: 500 },
-  brand: { role: 'primary', step: 400 },
-  brandEmphasis: { role: 'primary', step: 300 },
-  action: { role: 'primary', step: 400 },
-  actionEmphasis: { role: 'primary', step: 300 },
-};

package/src/swatches.ts

@@ -1,160 +0,0 @@
-import type { HexColor } from './hex';
-import { deltaEoklch, oklchToHex, parseHexToOklch } from './internal-culori';
-
-export const COLOR_SWATCH_STEPS = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950] as const;
-export type ColorSwatchStep = (typeof COLOR_SWATCH_STEPS)[number];
-
-export const COLOR_SWATCH_BASE_STEP = 500 as const;
-
-export type ColorSwatch = Record<ColorSwatchStep, HexColor>;
-
-export type ColorSwatchWarningCode =
-  | 'weak_step'
-  | 'weak_adjacent_delta'
-  | 'limited_lightness_range';
-
-export interface ColorSwatchWarning {
-  code: ColorSwatchWarningCode;
-  step?: ColorSwatchStep;
-  message: string;
-  deltaEFromBase?: number;
-}
-
-export interface ColorSwatchDiagnostics {
-  isUsable: boolean;
-  warnings: readonly ColorSwatchWarning[];
-  minAdjacentDelta: number;
-  maxAdjacentDelta: number;
-  lightnessRange: {
-    min: number;
-    max: number;
-  };
-}
-
-const BASELINE_LIGHTNESS_BY_STEP: Record<ColorSwatchStep, number> = {
-  50: 0.985,
-  100: 0.967,
-  200: 0.928,
-  300: 0.872,
-  400: 0.707,
-  500: 0.551,
-  600: 0.446,
-  700: 0.373,
-  800: 0.278,
-  900: 0.21,
-  950: 0.13,
-};
-
-const MIN_USABLE_ADJACENT_DELTA = 0.012;
-const MIN_USABLE_LIGHTNESS_RANGE = 0.35;
-
-/***
-  Clamp a number into the normalized zero-to-one range.
-*/
-function clamp01(value: number): number {
-  if (!Number.isFinite(value)) return 0;
-  return Math.min(1, Math.max(0, value));
-}
-
-/***
-  Return the chroma multiplier used for a swatch step.
-*/
-function chromaMultiplierForStep(step: ColorSwatchStep): number {
-  if (step <= 200) return 0.55;
-  if (step <= 400) return 0.75;
-  if (step === COLOR_SWATCH_BASE_STEP) return 1;
-  if (step <= 700) return 0.9;
-  return 0.8;
-}
-
-/***
-  Generate a full color swatch and diagnostics from a base color.
-*/
-export function generateColorSwatch(baseColor: HexColor): {
-  swatch: ColorSwatch;
-  diagnostics: ColorSwatchDiagnostics;
-} {
-  const baseOklch = parseHexToOklch(baseColor);
-  const baseOffset = baseOklch.l - BASELINE_LIGHTNESS_BY_STEP[COLOR_SWATCH_BASE_STEP];
-
-  const warnings: ColorSwatchWarning[] = [];
-  const swatch = {} as ColorSwatch;
-  const lightnessEntries: number[] = [];
-  const adjacentDeltas: number[] = [];
-
-  for (const step of COLOR_SWATCH_STEPS) {
-    if (step === COLOR_SWATCH_BASE_STEP) {
-      swatch[step] = baseColor;
-      lightnessEntries.push(baseOklch.l);
-      continue;
-    }
-
-    const targetL = clamp01(BASELINE_LIGHTNESS_BY_STEP[step] + baseOffset);
-    const targetC = clamp01(baseOklch.c * chromaMultiplierForStep(step));
-    const target = { ...baseOklch, l: targetL, c: targetC };
-    const hex = oklchToHex(target);
-    swatch[step] = hex;
-
-    const candidateOklch = parseHexToOklch(hex);
-    lightnessEntries.push(candidateOklch.l);
-
-    const deltaEFromBase = deltaEoklch(baseOklch, candidateOklch);
-    if (deltaEFromBase < 0.02) {
-      warnings.push({
-        code: 'weak_step',
-        step,
-        deltaEFromBase,
-        message: `Swatch step ${step} is visually close to the base color.`,
-      });
-    }
-  }
-
-  for (let index = 1; index < COLOR_SWATCH_STEPS.length; index++) {
-    const previousStep = COLOR_SWATCH_STEPS[index - 1];
-    const currentStep = COLOR_SWATCH_STEPS[index];
-    if (previousStep === undefined || currentStep === undefined) continue;
-
-    const previous = parseHexToOklch(swatch[previousStep]);
-    const current = parseHexToOklch(swatch[currentStep]);
-    const adjacentDelta = deltaEoklch(previous, current);
-    adjacentDeltas.push(adjacentDelta);
-
-    if (adjacentDelta < MIN_USABLE_ADJACENT_DELTA) {
-      warnings.push({
-        code: 'weak_adjacent_delta',
-        step: currentStep,
-        deltaEFromBase: adjacentDelta,
-        message: `Swatch step ${currentStep} is visually close to adjacent step ${previousStep}.`,
-      });
-    }
-  }
-
-  const minAdjacentDelta = Math.min(...adjacentDeltas);
-  const maxAdjacentDelta = Math.max(...adjacentDeltas);
-  const minLightness = Math.min(...lightnessEntries);
-  const maxLightness = Math.max(...lightnessEntries);
-  const lightnessRange = maxLightness - minLightness;
-
-  if (lightnessRange < MIN_USABLE_LIGHTNESS_RANGE) {
-    warnings.push({
-      code: 'limited_lightness_range',
-      message: 'Generated swatch has a limited lightness range.',
-    });
-  }
-
-  return {
-    swatch,
-    diagnostics: {
-      isUsable:
-        minAdjacentDelta >= MIN_USABLE_ADJACENT_DELTA &&
-        lightnessRange >= MIN_USABLE_LIGHTNESS_RANGE,
-      warnings,
-      minAdjacentDelta,
-      maxAdjacentDelta,
-      lightnessRange: {
-        min: minLightness,
-        max: maxLightness,
-      },
-    },
-  };
-}

package/src/theme-colors.ts

@@ -1,86 +0,0 @@
-import { type GeneratedHarmonyRoleColors, generateHarmonyRoleColors } from './harmony';
-import type { HexColor } from './hex';
-import { parseHexColorOrThrow } from './hex';
-import { type GeneratedNeutralMetadata, generateNeutralSwatch } from './neutral';
-import { type ColorSwatch, generateColorSwatch } from './swatches';
-
-export interface ThemeModeColorInput {
-  primaryColor: string;
-  harmony: GeneratedHarmonyRoleColors['harmony'];
-}
-
-export interface ThemeColorInput {
-  light: ThemeModeColorInput;
-  dark: ThemeModeColorInput;
-}
-
-export interface GeneratedThemeSwatches {
-  primary: ColorSwatch;
-  secondary?: ColorSwatch;
-  tertiary?: ColorSwatch;
-  quaternary?: ColorSwatch;
-  neutral: ColorSwatch;
-}
-
-export interface GeneratedThemeModeColors {
-  harmonyRoleColors: GeneratedHarmonyRoleColors;
-  swatches: GeneratedThemeSwatches;
-  neutral: GeneratedNeutralMetadata;
-}
-
-/***
-  Parse the primary color configured for a theme mode.
-*/
-export function getThemeModePrimaryHex(mode: ThemeModeColorInput): HexColor {
-  return parseHexColorOrThrow(mode.primaryColor);
-}
-
-/***
-  Generate harmony role colors, swatches, and neutral metadata for a theme mode.
-*/
-export function generateThemeModeColors(mode: ThemeModeColorInput): GeneratedThemeModeColors {
-  const primaryHex = getThemeModePrimaryHex(mode);
-  const harmonyRoleColors = generateHarmonyRoleColors(primaryHex, mode.harmony);
-
-  const primarySwatch = generateColorSwatch(harmonyRoleColors.primary.hex).swatch;
-  const secondarySwatch = harmonyRoleColors.secondary
-    ? generateColorSwatch(harmonyRoleColors.secondary.hex).swatch
-    : undefined;
-  const tertiarySwatch = harmonyRoleColors.tertiary
-    ? generateColorSwatch(harmonyRoleColors.tertiary.hex).swatch
-    : undefined;
-  const quaternarySwatch = harmonyRoleColors.quaternary
-    ? generateColorSwatch(harmonyRoleColors.quaternary.hex).swatch
-    : undefined;
-
-  const neutral = generateNeutralSwatch(harmonyRoleColors);
-  const swatches: GeneratedThemeSwatches = {
-    primary: primarySwatch,
-    neutral: neutral.neutral,
-    ...(secondarySwatch ? { secondary: secondarySwatch } : {}),
-    ...(tertiarySwatch ? { tertiary: tertiarySwatch } : {}),
-    ...(quaternarySwatch ? { quaternary: quaternarySwatch } : {}),
-  };
-
-  return {
-    harmonyRoleColors,
-    swatches,
-    neutral: {
-      neutralKeyColor: neutral.neutralKeyColor,
-      diagnostics: neutral.diagnostics,
-    },
-  };
-}
-
-/***
-  Generate light and dark theme color outputs from theme color input.
-*/
-export function generateThemeColors(theme: ThemeColorInput): {
-  light: GeneratedThemeModeColors;
-  dark: GeneratedThemeModeColors;
-} {
-  return {
-    light: generateThemeModeColors(theme.light),
-    dark: generateThemeModeColors(theme.dark),
-  };
-}