@ankhorage/zora 0.16.2 → 1.0.0

package/src/internal/color/roleHues.test.ts

@@ -1,197 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import {
-  assignZoraHarmonyRoleHues,
-  getZoraHueRoleAssignment,
-  type ZoraComputedHarmony,
-  type ZoraComputedHueRoles,
-  type ZoraHueRoleAssignment,
-  type ZoraHueRoleId,
-} from './index';
-
-function expectNormalizedHue(hue: number) {
-  expect(Number.isFinite(hue)).toBe(true);
-  expect(hue).toBeGreaterThanOrEqual(0);
-  expect(hue).toBeLessThan(360);
-}
-
-const ROLE_ORDER: readonly ZoraHueRoleId[] = [
-  'primary',
-  'secondary',
-  'accent',
-  'highlight',
-  'surfaceTint',
-];
-
-function expectEveryRoleOnce(roles: ReturnType<typeof assignZoraHarmonyRoleHues>) {
-  expect(roles.assignments).toHaveLength(ROLE_ORDER.length);
-  expect(roles.assignments.map((assignment) => assignment.role)).toEqual([...ROLE_ORDER]);
-}
-
-describe('assignZoraHarmonyRoleHues', () => {
-  test('monochromatic assigns every role to base', () => {
-    const harmony: ZoraComputedHarmony = {
-      kind: 'monochromatic',
-      orderedSlots: [{ id: 'base', hue: 100 }],
-    };
-
-    const roles: ZoraComputedHueRoles = assignZoraHarmonyRoleHues(harmony);
-
-    expectEveryRoleOnce(roles);
-    for (const assignment of roles.assignments) {
-      expect(assignment.sourceSlotId).toBe('base');
-      expect(assignment.hue).toBe(100);
-      expectNormalizedHue(assignment.hue);
-    }
-  });
-
-  test('complementary assigns accent/highlight to a', () => {
-    const harmony: ZoraComputedHarmony = {
-      kind: 'complementary',
-      orderedSlots: [
-        { id: 'base', hue: 100 },
-        { id: 'a', hue: 280 },
-      ],
-    };
-
-    const roles: ZoraComputedHueRoles = assignZoraHarmonyRoleHues(harmony);
-
-    expectEveryRoleOnce(roles);
-    const accent: ZoraHueRoleAssignment = getZoraHueRoleAssignment(roles, 'accent');
-    const highlight: ZoraHueRoleAssignment = getZoraHueRoleAssignment(roles, 'highlight');
-
-    expect(accent.sourceSlotId).toBe('a');
-    expect(highlight.sourceSlotId).toBe('a');
-    expect(getZoraHueRoleAssignment(roles, 'primary').sourceSlotId).toBe('base');
-    expect(getZoraHueRoleAssignment(roles, 'surfaceTint').sourceSlotId).toBe('base');
-  });
-
-  test('analogous assigns secondary/surfaceTint to a and accent/highlight to b', () => {
-    const harmony: ZoraComputedHarmony = {
-      kind: 'analogous',
-      orderedSlots: [
-        { id: 'base', hue: 100 },
-        { id: 'a', hue: 70 },
-        { id: 'b', hue: 130 },
-      ],
-    };
-
-    const roles = assignZoraHarmonyRoleHues(harmony);
-
-    expectEveryRoleOnce(roles);
-    expect(getZoraHueRoleAssignment(roles, 'secondary').sourceSlotId).toBe('a');
-    expect(getZoraHueRoleAssignment(roles, 'surfaceTint').sourceSlotId).toBe('a');
-    expect(getZoraHueRoleAssignment(roles, 'accent').sourceSlotId).toBe('b');
-    expect(getZoraHueRoleAssignment(roles, 'highlight').sourceSlotId).toBe('b');
-  });
-
-  test('splitComplementary assigns primary/surfaceTint to base and accent/highlight to b', () => {
-    const harmony: ZoraComputedHarmony = {
-      kind: 'splitComplementary',
-      orderedSlots: [
-        { id: 'base', hue: 100 },
-        { id: 'a', hue: 250 },
-        { id: 'b', hue: 310 },
-      ],
-    };
-
-    const roles = assignZoraHarmonyRoleHues(harmony);
-
-    expectEveryRoleOnce(roles);
-    expect(getZoraHueRoleAssignment(roles, 'primary').sourceSlotId).toBe('base');
-    expect(getZoraHueRoleAssignment(roles, 'surfaceTint').sourceSlotId).toBe('base');
-    expect(getZoraHueRoleAssignment(roles, 'accent').sourceSlotId).toBe('b');
-    expect(getZoraHueRoleAssignment(roles, 'highlight').sourceSlotId).toBe('b');
-  });
-
-  test('triadic assigns primary/surfaceTint to base and secondary/accent across a/b', () => {
-    const harmony: ZoraComputedHarmony = {
-      kind: 'triadic',
-      orderedSlots: [
-        { id: 'base', hue: 100 },
-        { id: 'a', hue: 220 },
-        { id: 'b', hue: 340 },
-      ],
-    };
-
-    const roles = assignZoraHarmonyRoleHues(harmony);
-
-    expectEveryRoleOnce(roles);
-    expect(getZoraHueRoleAssignment(roles, 'primary').sourceSlotId).toBe('base');
-    expect(getZoraHueRoleAssignment(roles, 'surfaceTint').sourceSlotId).toBe('base');
-    expect(getZoraHueRoleAssignment(roles, 'secondary').sourceSlotId).toBe('a');
-    expect(getZoraHueRoleAssignment(roles, 'accent').sourceSlotId).toBe('b');
-  });
-
-  test('tetradic assigns highlight to c', () => {
-    const harmony: ZoraComputedHarmony = {
-      kind: 'tetradic',
-      orderedSlots: [
-        { id: 'base', hue: 100 },
-        { id: 'a', hue: 190 },
-        { id: 'b', hue: 280 },
-        { id: 'c', hue: 10 },
-      ],
-    };
-
-    const roles = assignZoraHarmonyRoleHues(harmony);
-
-    expectEveryRoleOnce(roles);
-    expect(getZoraHueRoleAssignment(roles, 'highlight').sourceSlotId).toBe('c');
-  });
-
-  test('every assignment hue is normalized to [0, 360)', () => {
-    const harmony: ZoraComputedHarmony = {
-      kind: 'complementary',
-      orderedSlots: [
-        { id: 'base', hue: -10 },
-        { id: 'a', hue: 370 },
-      ],
-    };
-
-    const roles = assignZoraHarmonyRoleHues(harmony);
-
-    expectEveryRoleOnce(roles);
-    for (const assignment of roles.assignments) {
-      expectNormalizedHue(assignment.hue);
-    }
-  });
-
-  test('is deterministic for the same computed harmony', () => {
-    const harmony: ZoraComputedHarmony = {
-      kind: 'analogous',
-      orderedSlots: [
-        { id: 'base', hue: 100 },
-        { id: 'a', hue: 70 },
-        { id: 'b', hue: 130 },
-      ],
-    };
-
-    expect(assignZoraHarmonyRoleHues(harmony)).toEqual(assignZoraHarmonyRoleHues(harmony));
-  });
-
-  test('falls back when a preferred non-base slot is missing', () => {
-    const harmony: ZoraComputedHarmony = {
-      kind: 'analogous',
-      orderedSlots: [
-        { id: 'base', hue: 100 },
-        { id: 'a', hue: 70 },
-      ],
-    };
-
-    const roles = assignZoraHarmonyRoleHues(harmony);
-
-    expectEveryRoleOnce(roles);
-    expect(getZoraHueRoleAssignment(roles, 'accent').sourceSlotId).toBe('a');
-    expect(getZoraHueRoleAssignment(roles, 'highlight').sourceSlotId).toBe('a');
-  });
-
-  test('throws a clear error when the base slot is missing', () => {
-    const harmony: ZoraComputedHarmony = {
-      kind: 'complementary',
-      orderedSlots: [{ id: 'a', hue: 200 }],
-    };
-
-    expect(() => assignZoraHarmonyRoleHues(harmony)).toThrow('base');
-  });
-});

package/src/internal/color/roleHues.ts

@@ -1,142 +0,0 @@
-import type { ZoraColorHarmony } from '../../theme/types';
-import type { ZoraComputedHarmony, ZoraHarmonySlot, ZoraHarmonySlotId } from './harmony';
-import { normalizeHueDegrees } from './hue';
-
-export type ZoraHueRoleId = 'primary' | 'secondary' | 'accent' | 'highlight' | 'surfaceTint';
-
-export interface ZoraHueRoleAssignment {
-  role: ZoraHueRoleId;
-  hue: number;
-  sourceSlotId: ZoraHarmonySlotId;
-}
-
-export interface ZoraComputedHueRoles {
-  harmony: ZoraColorHarmony;
-  assignments: readonly ZoraHueRoleAssignment[];
-}
-
-function findSlot(
-  harmony: ZoraComputedHarmony,
-  id: ZoraHarmonySlotId,
-): ZoraHarmonySlot | undefined {
-  return harmony.orderedSlots.find((slot) => slot.id === id);
-}
-
-function requireBaseSlot(harmony: ZoraComputedHarmony): ZoraHarmonySlot {
-  const base = findSlot(harmony, 'base');
-  if (!base) {
-    throw new Error(`[zora] Expected harmony to include a base slot (kind: ${harmony.kind}).`);
-  }
-  return base;
-}
-
-function assignRole(
-  role: ZoraHueRoleId,
-  harmony: ZoraComputedHarmony,
-  preferred: ZoraHarmonySlotId,
-  fallback: ZoraHarmonySlotId = 'base',
-): ZoraHueRoleAssignment {
-  const base = requireBaseSlot(harmony);
-  const preferredSlot = findSlot(harmony, preferred);
-  const fallbackSlot = findSlot(harmony, fallback);
-  const chosenSlot = preferredSlot ?? fallbackSlot ?? base;
-
-  return {
-    role,
-    hue: normalizeHueDegrees(chosenSlot.hue),
-    sourceSlotId: chosenSlot.id,
-  };
-}
-
-export function assignZoraHarmonyRoleHues(harmony: ZoraComputedHarmony): ZoraComputedHueRoles {
-  const { kind } = harmony;
-
-  if (kind === 'monochromatic') {
-    return {
-      harmony: kind,
-      assignments: [
-        assignRole('primary', harmony, 'base'),
-        assignRole('secondary', harmony, 'base'),
-        assignRole('accent', harmony, 'base'),
-        assignRole('highlight', harmony, 'base'),
-        assignRole('surfaceTint', harmony, 'base'),
-      ],
-    };
-  }
-
-  if (kind === 'complementary') {
-    return {
-      harmony: kind,
-      assignments: [
-        assignRole('primary', harmony, 'base'),
-        assignRole('secondary', harmony, 'base'),
-        assignRole('accent', harmony, 'a'),
-        assignRole('highlight', harmony, 'a'),
-        assignRole('surfaceTint', harmony, 'base'),
-      ],
-    };
-  }
-
-  if (kind === 'analogous') {
-    return {
-      harmony: kind,
-      assignments: [
-        assignRole('primary', harmony, 'base'),
-        assignRole('secondary', harmony, 'a'),
-        assignRole('accent', harmony, 'b', 'a'),
-        assignRole('highlight', harmony, 'b', 'a'),
-        assignRole('surfaceTint', harmony, 'a'),
-      ],
-    };
-  }
-
-  if (kind === 'splitComplementary') {
-    return {
-      harmony: kind,
-      assignments: [
-        assignRole('primary', harmony, 'base'),
-        assignRole('secondary', harmony, 'a'),
-        assignRole('accent', harmony, 'b', 'a'),
-        assignRole('highlight', harmony, 'b', 'a'),
-        assignRole('surfaceTint', harmony, 'base'),
-      ],
-    };
-  }
-
-  if (kind === 'triadic') {
-    return {
-      harmony: kind,
-      assignments: [
-        assignRole('primary', harmony, 'base'),
-        assignRole('secondary', harmony, 'a'),
-        assignRole('accent', harmony, 'b', 'a'),
-        assignRole('highlight', harmony, 'b', 'a'),
-        assignRole('surfaceTint', harmony, 'base'),
-      ],
-    };
-  }
-
-  return {
-    harmony: kind,
-    assignments: [
-      assignRole('primary', harmony, 'base'),
-      assignRole('secondary', harmony, 'a'),
-      assignRole('accent', harmony, 'b', 'a'),
-      assignRole('highlight', harmony, 'c', 'b'),
-      assignRole('surfaceTint', harmony, 'base'),
-    ],
-  };
-}
-
-export function getZoraHueRoleAssignment(
-  roles: ZoraComputedHueRoles,
-  role: ZoraHueRoleId,
-): ZoraHueRoleAssignment {
-  const found = roles.assignments.find((assignment) => assignment.role === role);
-  if (!found) {
-    throw new Error(
-      `[zora] Expected a hue-role assignment for "${role}" (harmony: ${roles.harmony}).`,
-    );
-  }
-  return found;
-}

package/src/internal/color/roleScales.test.ts

@@ -1,220 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import type { ZoraColorTone, ZoraHexColor } from '../../theme/types';
-import {
-  assignZoraHarmonyRoleHues,
-  computeZoraHarmony,
-  createZoraRoleColorScales,
-  getZoraRoleColorScale,
-  parseHexToOklch,
-  ZORA_COLOR_SCALE_ROLE_ORDER,
-  ZORA_COLOR_SCALE_STEPS,
-  type ZoraColorScale,
-  type ZoraColorScaleStep,
-  type ZoraComputedHueRoles,
-  type ZoraRoleColorScale,
-} from './index';
-
-function isSixDigitLowercaseHexColor(value: string): value is ZoraHexColor {
-  return /^#[0-9a-f]{6}$/.test(value);
-}
-
-function hueDeltaDegrees(a: number, b: number): number {
-  const raw = Math.abs(a - b) % 360;
-  return Math.min(raw, 360 - raw);
-}
-
-function getStepValues(scale: ZoraColorScale): { step: ZoraColorScaleStep; hex: ZoraHexColor }[] {
-  return ZORA_COLOR_SCALE_STEPS.map((step) => ({ step, hex: scale[step] }));
-}
-
-function assertScaleKeys(scale: ZoraColorScale) {
-  const keys = Object.keys(scale)
-    .map((key) => Number(key))
-    .sort((a, b) => a - b);
-
-  expect(keys).toEqual([...ZORA_COLOR_SCALE_STEPS]);
-}
-
-function assertNoPureBlackOrWhite(scale: ZoraColorScale) {
-  const values = getStepValues(scale).map(({ hex }) => hex);
-  expect(values).not.toContain('#000000');
-  expect(values).not.toContain('#ffffff');
-}
-
-function buildHueRoles(assignments: ZoraComputedHueRoles['assignments']): ZoraComputedHueRoles {
-  return {
-    harmony: 'tetradic',
-    assignments,
-  };
-}
-
-function createCompleteHueRoles(): ZoraComputedHueRoles {
-  return buildHueRoles([
-    { role: 'primary', hue: 120, sourceSlotId: 'base' },
-    { role: 'secondary', hue: 200, sourceSlotId: 'a' },
-    { role: 'accent', hue: 280, sourceSlotId: 'b' },
-    { role: 'highlight', hue: 20, sourceSlotId: 'c' },
-    { role: 'surfaceTint', hue: 160, sourceSlotId: 'a' },
-  ]);
-}
-
-function createScales(colorTone: ZoraColorTone = 'jewel') {
-  return createZoraRoleColorScales({
-    colorTone,
-    hueRoles: createCompleteHueRoles(),
-    seed: '#0f766e',
-  });
-}
-
-function requireHueBackedSourceHue(role: ZoraRoleColorScale): number {
-  if (typeof role.sourceHue !== 'number') {
-    throw new Error(`[zora] Expected "${role.role}" role scale to include a sourceHue.`);
-  }
-  return role.sourceHue;
-}
-
-describe('createZoraRoleColorScales', () => {
-  test('returns all roles exactly once in deterministic order', () => {
-    const scales = createScales();
-
-    expect(scales.roles).toHaveLength(ZORA_COLOR_SCALE_ROLE_ORDER.length);
-    expect(scales.roles.map((entry) => entry.role)).toEqual([...ZORA_COLOR_SCALE_ROLE_ORDER]);
-    expect(new Set(scales.roles.map((entry) => entry.role)).size).toBe(
-      ZORA_COLOR_SCALE_ROLE_ORDER.length,
-    );
-  });
-
-  test('every scale contains exactly all 50–950 keys and valid lowercase 6-digit hex values', () => {
-    const scales = createScales();
-
-    for (const role of scales.roles) {
-      assertScaleKeys(role.scale);
-      for (const { hex } of getStepValues(role.scale)) {
-        expect(isSixDigitLowercaseHexColor(hex)).toBe(true);
-      }
-    }
-  });
-
-  test('output is deterministic for the same input', () => {
-    expect(createScales()).toEqual(createScales());
-  });
-
-  test('role hue is preserved approximately for mid steps', () => {
-    const scales = createZoraRoleColorScales({
-      colorTone: 'jewel',
-      hueRoles: buildHueRoles([
-        { role: 'primary', hue: 115, sourceSlotId: 'base' },
-        { role: 'secondary', hue: 210, sourceSlotId: 'a' },
-        { role: 'accent', hue: 300, sourceSlotId: 'b' },
-        { role: 'highlight', hue: 25, sourceSlotId: 'c' },
-        { role: 'surfaceTint', hue: 165, sourceSlotId: 'a' },
-      ]),
-      seed: '#0f766e',
-    });
-
-    const midSteps: ZoraColorScaleStep[] = [400, 500, 600, 700];
-    for (const roleId of ['primary', 'secondary', 'accent', 'highlight', 'surfaceTint'] as const) {
-      const role = getZoraRoleColorScale(scales, roleId);
-      const expectedHue = requireHueBackedSourceHue(role);
-
-      for (const step of midSteps) {
-        const oklch = parseHexToOklch(role.scale[step]);
-        expect(hueDeltaDegrees(expectedHue, oklch.h)).toBeLessThan(25);
-      }
-    }
-  });
-
-  test('surfaceTint scale has lower chroma than primary/accent/highlight for mid steps', () => {
-    const scales = createScales('jewel');
-    const surfaceTint = getZoraRoleColorScale(scales, 'surfaceTint').scale;
-    const primary = getZoraRoleColorScale(scales, 'primary').scale;
-    const accent = getZoraRoleColorScale(scales, 'accent').scale;
-    const highlight = getZoraRoleColorScale(scales, 'highlight').scale;
-    const step: ZoraColorScaleStep = 500;
-    const surfaceTintChroma = parseHexToOklch(surfaceTint[step]).c;
-
-    expect(surfaceTintChroma).toBeLessThan(parseHexToOklch(primary[step]).c);
-    expect(surfaceTintChroma).toBeLessThan(parseHexToOklch(accent[step]).c);
-    expect(surfaceTintChroma).toBeLessThan(parseHexToOklch(highlight[step]).c);
-  });
-
-  test('colorTone changes role chroma behavior internally', () => {
-    const neutral = createScales('neutral');
-    const fluorescent = createScales('fluorescent');
-    const step: ZoraColorScaleStep = 500;
-
-    const neutralPrimary = parseHexToOklch(getZoraRoleColorScale(neutral, 'primary').scale[step]).c;
-    const fluorescentPrimary = parseHexToOklch(
-      getZoraRoleColorScale(fluorescent, 'primary').scale[step],
-    ).c;
-
-    expect(fluorescentPrimary).toBeGreaterThan(neutralPrimary);
-  });
-
-  test('pastel keeps surfaceTint lower chroma than fluorescent foreground roles', () => {
-    const pastel = createScales('pastel');
-    const fluorescent = createScales('fluorescent');
-    const step: ZoraColorScaleStep = 500;
-
-    const pastelSurfaceTint = parseHexToOklch(
-      getZoraRoleColorScale(pastel, 'surfaceTint').scale[step],
-    ).c;
-    const fluorescentAccent = parseHexToOklch(
-      getZoraRoleColorScale(fluorescent, 'accent').scale[step],
-    ).c;
-
-    expect(pastelSurfaceTint).toBeLessThan(fluorescentAccent);
-  });
-
-  test('neutral scale has low chroma', () => {
-    const neutral = getZoraRoleColorScale(createScales(), 'neutral').scale;
-
-    for (const { hex } of getStepValues(neutral)) {
-      expect(parseHexToOklch(hex).c).toBeLessThanOrEqual(0.03);
-    }
-  });
-
-  test('missing required hue role throws a clear error', () => {
-    const hueRoles = buildHueRoles([
-      { role: 'primary', hue: 120, sourceSlotId: 'base' },
-      { role: 'secondary', hue: 200, sourceSlotId: 'a' },
-      { role: 'accent', hue: 280, sourceSlotId: 'b' },
-      { role: 'surfaceTint', hue: 160, sourceSlotId: 'a' },
-    ]);
-
-    expect(() =>
-      createZoraRoleColorScales({ colorTone: 'jewel', hueRoles, seed: '#0f766e' }),
-    ).toThrow('highlight');
-  });
-
-  test('no role scale contains pure black/white by default', () => {
-    const scales = createScales();
-
-    for (const role of scales.roles) {
-      assertNoPureBlackOrWhite(role.scale);
-    }
-  });
-
-  test('does not mutate input hueRoles', () => {
-    const hueRoles = createCompleteHueRoles();
-    const snapshot = JSON.stringify(hueRoles);
-
-    createZoraRoleColorScales({ colorTone: 'jewel', hueRoles, seed: '#0f766e' });
-
-    expect(JSON.stringify(hueRoles)).toBe(snapshot);
-  });
-
-  test('integration: harmony -> role hues -> role scales pipeline connects', () => {
-    const seed: ZoraHexColor = '#0f766e';
-    const harmony = computeZoraHarmony(seed, 'tetradic');
-    const hueRoles = assignZoraHarmonyRoleHues(harmony);
-
-    const scales = createZoraRoleColorScales({ colorTone: 'jewel', hueRoles, seed });
-
-    expect(scales.roles.map((entry) => entry.role)).toEqual([...ZORA_COLOR_SCALE_ROLE_ORDER]);
-    for (const role of scales.roles) {
-      assertScaleKeys(role.scale);
-    }
-  });
-});

package/src/internal/color/roleScales.ts

@@ -1,127 +0,0 @@
-import type { ZoraColorTone, ZoraHexColor } from '../../theme/types';
-import { getZoraColorToneRecipe } from './colorToneRecipes';
-import { parseHexToOklch } from './oklch';
-import {
-  getZoraHueRoleAssignment,
-  type ZoraComputedHueRoles,
-  type ZoraHueRoleId,
-} from './roleHues';
-import {
-  createZoraHueScale,
-  type CreateZoraHueScaleOptions,
-  createZoraNeutralScale,
-  type ZoraHueScaleRoleId,
-} from './scales';
-import type { ZoraColorScale } from './types';
-
-export type ZoraColorScaleRoleId =
-  | 'primary'
-  | 'secondary'
-  | 'accent'
-  | 'highlight'
-  | 'surfaceTint'
-  | 'neutral';
-
-export const ZORA_COLOR_SCALE_ROLE_ORDER: readonly ZoraColorScaleRoleId[] = [
-  'primary',
-  'secondary',
-  'accent',
-  'highlight',
-  'surfaceTint',
-  'neutral',
-];
-
-export interface ZoraRoleColorScale {
-  role: ZoraColorScaleRoleId;
-  sourceHue?: number;
-  scale: ZoraColorScale;
-}
-
-export interface ZoraComputedRoleColorScales {
-  roles: readonly ZoraRoleColorScale[];
-}
-
-export function getZoraRoleColorScale(
-  scales: ZoraComputedRoleColorScales,
-  role: ZoraColorScaleRoleId,
-): ZoraRoleColorScale {
-  const found = scales.roles.find((entry) => entry.role === role);
-  if (!found) {
-    throw new Error(`[zora] Expected role color scales to include "${role}".`);
-  }
-  return found;
-}
-
-function resolveSeedChroma(seed: ZoraHexColor): number {
-  return parseHexToOklch(seed).c;
-}
-
-function createHueBackedRoleScale(options: {
-  colorTone: ZoraColorTone;
-  hueRoles: ZoraComputedHueRoles;
-  seedChroma: number;
-  role: ZoraHueRoleId;
-}): ZoraRoleColorScale {
-  const assignment = getZoraHueRoleAssignment(options.hueRoles, options.role);
-  const colorToneRecipe = getZoraColorToneRecipe(options.colorTone);
-  const hueScaleRole: ZoraHueScaleRoleId = options.role;
-  const hueScaleOptions: CreateZoraHueScaleOptions = {
-    hue: assignment.hue,
-    seedChroma: options.seedChroma,
-    role: hueScaleRole,
-    colorToneRecipe,
-  };
-
-  return {
-    role: options.role,
-    sourceHue: assignment.hue,
-    scale: createZoraHueScale(hueScaleOptions),
-  };
-}
-
-export function createZoraRoleColorScales(options: {
-  hueRoles: ZoraComputedHueRoles;
-  seed: ZoraHexColor;
-  colorTone: ZoraColorTone;
-}): ZoraComputedRoleColorScales {
-  const seedChroma = resolveSeedChroma(options.seed);
-
-  const roles: ZoraRoleColorScale[] = [
-    createHueBackedRoleScale({
-      colorTone: options.colorTone,
-      hueRoles: options.hueRoles,
-      seedChroma,
-      role: 'primary',
-    }),
-    createHueBackedRoleScale({
-      colorTone: options.colorTone,
-      hueRoles: options.hueRoles,
-      seedChroma,
-      role: 'secondary',
-    }),
-    createHueBackedRoleScale({
-      colorTone: options.colorTone,
-      hueRoles: options.hueRoles,
-      seedChroma,
-      role: 'accent',
-    }),
-    createHueBackedRoleScale({
-      colorTone: options.colorTone,
-      hueRoles: options.hueRoles,
-      seedChroma,
-      role: 'highlight',
-    }),
-    createHueBackedRoleScale({
-      colorTone: options.colorTone,
-      hueRoles: options.hueRoles,
-      seedChroma,
-      role: 'surfaceTint',
-    }),
-    {
-      role: 'neutral',
-      scale: createZoraNeutralScale(options.seed),
-    },
-  ];
-
-  return { roles };
-}