@ankhorage/zora 18.0.1 → 19.0.1

package/src/theme/compileZoraTheme.ts

@@ -1,177 +0,0 @@
-import { generateThemeModeColors, selectColorSwatchStep } from '@ankhorage/color-theory';
-import type { ThemeConfig } from '@ankhorage/contracts';
-import { createTheme } from '@ankhorage/surface/theme';
-
-import type {
-  ZoraComputedTheme,
-  ZoraComputedThemeMode,
-  ZoraThemeCompilationDiagnostic,
-  ZoraThemeCompilationOptions,
-  ZoraThemeMode,
-  ZoraThemeProvenanceEntry,
-  ZoraThemeSelectionResult,
-  ZoraThemeSelectionTarget,
-} from './types';
-
-const CONTRACTS_OWNER = '@ankhorage/contracts';
-const COLOR_THEORY_OWNER = '@ankhorage/color-theory';
-const SURFACE_OWNER = '@ankhorage/surface';
-const ZORA_OWNER = '@ankhorage/zora';
-
-/***
- * Compile canonical theme source into Color Theory evidence and resolved Surface themes.
- * This function is pure and does not mount React or reproduce owner algorithms.
- */
-export function compileZoraTheme(
-  themeConfig: ThemeConfig,
-  options: ZoraThemeCompilationOptions = {},
-): ZoraComputedTheme {
-  const light = compileMode(themeConfig, 'light', options.selectionTargets?.light ?? []);
-  const dark = compileMode(themeConfig, 'dark', options.selectionTargets?.dark ?? []);
-  const diagnostics = [...light.diagnostics, ...dark.diagnostics];
-
-  return {
-    themeConfig,
-    light,
-    dark,
-    diagnostics,
-    provenance: createRootProvenance(themeConfig),
-  };
-}
-
-/*** Compile one canonical mode and compare the independent owner results. */
-function compileMode(
-  themeConfig: ThemeConfig,
-  mode: ZoraThemeMode,
-  targets: readonly ZoraThemeSelectionTarget[],
-): ZoraComputedThemeMode {
-  const modeConfig = mode === 'light' ? themeConfig.light : themeConfig.dark;
-  const generated = generateThemeModeColors(modeConfig);
-  const surfaceTheme = createTheme(themeConfig, mode);
-  const { diagnostics, selections } = resolveSelections(generated, mode, targets);
-
-  if (!outputsAgree(generated, surfaceTheme.colorDiagnostics.generated)) {
-    diagnostics.push({
-      code: 'generated-output-divergence',
-      message: 'Surface and Color Theory returned different generated color evidence.',
-      mode,
-      path: `${mode}.generated`,
-      severity: 'error',
-    });
-  }
-
-  return {
-    mode,
-    generated,
-    surfaceTheme,
-    selections,
-    diagnostics,
-    provenance: createModeProvenance(mode, targets),
-  };
-}
-
-/*** Resolve measurable swatch targets without substituting unavailable roles. */
-function resolveSelections(
-  generated: ZoraComputedThemeMode['generated'],
-  mode: ZoraThemeMode,
-  targets: readonly ZoraThemeSelectionTarget[],
-): {
-  diagnostics: ZoraThemeCompilationDiagnostic[];
-  selections: ZoraThemeSelectionResult[];
-} {
-  const diagnostics: ZoraThemeCompilationDiagnostic[] = [];
-  const selections = targets.map((request) => {
-    const swatch = generated.swatches[request.swatch];
-    const result = swatch
-      ? selectColorSwatchStep(swatch, request.target, request.contexts, request.tiePolicy)
-      : null;
-
-    if (!swatch) diagnostics.push(createMissingSwatchDiagnostic(mode, request));
-    else if (!result?.selected) diagnostics.push(createUnresolvedTargetDiagnostic(mode, request));
-
-    return { request, result };
-  });
-
-  return { diagnostics, selections };
-}
-
-/*** Describe a requested swatch that the selected harmony does not generate. */
-function createMissingSwatchDiagnostic(
-  mode: ZoraThemeMode,
-  request: ZoraThemeSelectionTarget,
-): ZoraThemeCompilationDiagnostic {
-  return {
-    code: 'missing-target-swatch',
-    message: `The selected harmony does not generate the '${request.swatch}' swatch.`,
-    mode,
-    path: `${mode}.selectionTargets.${request.id}`,
-    severity: 'error',
-  };
-}
-
-/*** Describe a measurable target that has no passing swatch candidate. */
-function createUnresolvedTargetDiagnostic(
-  mode: ZoraThemeMode,
-  request: ZoraThemeSelectionTarget,
-): ZoraThemeCompilationDiagnostic {
-  return {
-    code: 'unresolved-selection-target',
-    message: `No '${request.swatch}' step satisfies selection target '${request.id}'.`,
-    mode,
-    path: `${mode}.selectionTargets.${request.id}`,
-    severity: 'error',
-  };
-}
-
-/*** Record direct source and Surface-owned default provenance. */
-function createRootProvenance(themeConfig: ThemeConfig): ZoraThemeProvenanceEntry[] {
-  return [
-    { path: 'themeConfig', origin: 'direct', owner: CONTRACTS_OWNER },
-    {
-      path: 'themeConfig.tokens',
-      origin: themeConfig.tokens ? 'direct' : 'defaulted',
-      owner: themeConfig.tokens ? CONTRACTS_OWNER : SURFACE_OWNER,
-    },
-  ];
-}
-
-/*** Record the owner transformation chain for one compiled mode. */
-function createModeProvenance(
-  mode: ZoraThemeMode,
-  targets: readonly ZoraThemeSelectionTarget[],
-): ZoraThemeProvenanceEntry[] {
-  const inputPath = `themeConfig.${mode}`;
-  const entries: ZoraThemeProvenanceEntry[] = [
-    { path: inputPath, origin: 'direct', owner: CONTRACTS_OWNER },
-    {
-      path: `${mode}.generated`,
-      origin: 'derived',
-      owner: COLOR_THEORY_OWNER,
-      inputs: [inputPath],
-    },
-    {
-      path: `${mode}.surfaceTheme`,
-      origin: 'derived',
-      owner: SURFACE_OWNER,
-      inputs: ['themeConfig', inputPath],
-    },
-  ];
-
-  for (const target of targets) {
-    const targetPath = `${mode}.selectionTargets.${target.id}`;
-    entries.push({ path: targetPath, origin: 'direct', owner: ZORA_OWNER });
-    entries.push({
-      path: `${mode}.selections.${target.id}`,
-      origin: 'derived',
-      owner: COLOR_THEORY_OWNER,
-      inputs: [`${mode}.generated.swatches.${target.swatch}`, targetPath],
-    });
-  }
-
-  return entries;
-}
-
-/*** Compare deterministic owner result records for divergence diagnostics. */
-function outputsAgree(left: unknown, right: unknown): boolean {
-  return JSON.stringify(left) === JSON.stringify(right);
-}

package/src/theme/createZoraThemeConfig.test.ts

@@ -1,75 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { createZoraThemeConfig } from './createZoraThemeConfig';
-import { zoraDefaultTheme } from './zoraDefaultTheme';
-
-describe('createZoraThemeConfig', () => {
-  test('converts the default theme seed into a surface config', () => {
-    const themeConfig = createZoraThemeConfig();
-
-    expect(themeConfig.id).toBe('zora');
-    expect(themeConfig.name).toBe('ZORA');
-    expect(themeConfig.light.primaryColor).toBe(zoraDefaultTheme.primaryColor);
-    expect(themeConfig.light.harmony).toBe('analogous');
-    expect(themeConfig.dark.primaryColor).toBe(zoraDefaultTheme.primaryColor);
-    expect(themeConfig.dark.harmony).toBe('analogous');
-  });
-
-  test('uses theme.name directly without fallback to id', () => {
-    const themeConfig = createZoraThemeConfig({
-      id: 'studio',
-      name: 'Studio',
-      appCategory: 'developer_tools',
-      primaryColor: '#0f766e',
-      harmony: 'analogous',
-    });
-
-    expect(themeConfig.id).toBe('studio');
-    expect(themeConfig.name).toBe('Studio');
-  });
-
-  test('preserves the same primaryColor for both light and dark', () => {
-    const primary = '#2563eb';
-    const themeConfig = createZoraThemeConfig({
-      id: 'test',
-      name: 'Test',
-      appCategory: 'utilities_tools',
-      primaryColor: primary,
-      harmony: 'triadic',
-    });
-
-    expect(themeConfig.light.primaryColor).toBe(primary);
-    expect(themeConfig.dark.primaryColor).toBe(primary);
-  });
-
-  test('validates public primaryColor strings during config conversion', () => {
-    expect(() =>
-      createZoraThemeConfig({
-        id: 'bad-theme',
-        name: 'Bad Theme',
-        appCategory: 'utilities_tools',
-        primaryColor: 'blue',
-        harmony: 'triadic',
-      }),
-    ).toThrow();
-  });
-
-  test('output has no colorTone field', () => {
-    const themeConfig = createZoraThemeConfig();
-
-    expect('colorTone' in themeConfig.light).toBe(false);
-    expect('colorTone' in themeConfig.dark).toBe(false);
-  });
-
-  test('surfaceConfig.name equals theme.name', () => {
-    const themeConfig = createZoraThemeConfig({
-      id: 'my-theme',
-      name: 'My Theme',
-      appCategory: 'games',
-      primaryColor: '#7c3aed',
-      harmony: 'complementary',
-    });
-
-    expect(themeConfig.name).toBe('My Theme');
-  });
-});

package/src/theme/createZoraThemeConfig.ts

@@ -1,23 +0,0 @@
-import { parseHexColorOrThrow } from '@ankhorage/color-theory';
-import type { ThemeConfig } from '@ankhorage/contracts';
-
-import type { ZoraTheme } from './types';
-import { zoraDefaultTheme } from './zoraDefaultTheme';
-
-/*** Convert the concise ZORA design seed into canonical persisted theme source. */
-export function createZoraThemeConfig(theme: ZoraTheme = zoraDefaultTheme): ThemeConfig {
-  const primaryColor = parseHexColorOrThrow(theme.primaryColor);
-
-  return {
-    id: theme.id,
-    name: theme.name,
-    light: {
-      primaryColor,
-      harmony: theme.harmony,
-    },
-    dark: {
-      primaryColor,
-      harmony: theme.harmony,
-    },
-  };
-}

package/src/theme/index.ts

@@ -1,10 +0,0 @@
-export * from './public';
-export { ThemeModeToggle } from './ThemeModeToggle';
-export type { ThemeModeToggleProps } from './ThemeModeToggleProps';
-export { useZoraTheme } from './useZoraTheme';
-export { withZoraThemeScope } from './withZoraThemeScope';
-export type { ZoraBaseProps } from './ZoraBaseProps';
-export type { ZoraProviderProps, ZoraToastCapability } from './ZoraProvider';
-export { ZoraProvider } from './ZoraProvider';
-export type { ZoraThemeScopeProps } from './ZoraThemeScope';
-export { ZoraThemeScope } from './ZoraThemeScope';

package/src/theme/public.ts

@@ -1,18 +0,0 @@
-export { compileZoraTheme } from './compileZoraTheme';
-export { createZoraThemeConfig } from './createZoraThemeConfig';
-export type {
-  ZoraComputedTheme,
-  ZoraComputedThemeMode,
-  ZoraTheme,
-  ZoraThemeCompilationDiagnostic,
-  ZoraThemeCompilationDiagnosticCode,
-  ZoraThemeCompilationOptions,
-  ZoraThemeId,
-  ZoraThemeMode,
-  ZoraThemeProvenanceEntry,
-  ZoraThemeSelectionResult,
-  ZoraThemeSelectionTarget,
-  ZoraThemeSwatchRole,
-  ZoraThemeValueOrigin,
-} from './types';
-export { zoraDefaultTheme } from './zoraDefaultTheme';

package/src/theme/resolveThemeModeToggleState.ts

@@ -1,21 +0,0 @@
-import type { ZoraThemeMode } from './types';
-
-interface ThemeModeToggleState {
-  readonly iconName: 'moon-outline' | 'sunny-outline';
-  readonly label: 'Use dark mode' | 'Use light mode';
-  readonly nextMode: ZoraThemeMode;
-}
-
-export function resolveThemeModeToggleState(mode: ZoraThemeMode): ThemeModeToggleState {
-  return mode === 'dark'
-    ? {
-        iconName: 'sunny-outline',
-        label: 'Use light mode',
-        nextMode: 'light',
-      }
-    : {
-        iconName: 'moon-outline',
-        label: 'Use dark mode',
-        nextMode: 'dark',
-      };
-}

package/src/theme/resolveZoraScopedThemeId.ts

@@ -1,25 +0,0 @@
-import type { ZoraThemeId } from './types';
-
-export function resolveZoraScopedThemeId({
-  desiredThemeId,
-  inheritedThemeId,
-}: {
-  desiredThemeId: ZoraThemeId | undefined;
-  inheritedThemeId: ZoraThemeId;
-}): ZoraThemeId {
-  if (desiredThemeId === undefined || desiredThemeId === inheritedThemeId) {
-    return inheritedThemeId;
-  }
-
-  const message = [
-    `Unknown ZORA theme id '${desiredThemeId}'.`,
-    'Theme registries are not available yet; register the theme before using themeId scopes.',
-  ].join(' ');
-
-  if (process.env.NODE_ENV === 'production') {
-    console.warn(message);
-    return inheritedThemeId;
-  }
-
-  throw new Error(message);
-}

package/src/theme/resolveZoraThemeRecipe.ts

@@ -1,91 +0,0 @@
-import type { ThemeConfig, ThemeRecipeOverrideValue } from '@ankhorage/contracts';
-
-import { ZORA_THEME_RECIPE_META } from '../metadata/themeRecipeMeta';
-import type { ZoraThemeRecipeFieldMeta, ZoraThemeTokenFamily } from '../metadata/themeRecipeTypes';
-
-interface ZoraThemeRecipeRuntimeTheme {
-  readonly config: ThemeConfig;
-  readonly colors: object;
-  readonly spacing: object;
-  readonly radii: object;
-  readonly shadows: object;
-  readonly typography: {
-    readonly sizes: object;
-    readonly weights: object;
-    readonly headings: object;
-  };
-}
-
-const recipeMetaByName = new Map(Object.entries(ZORA_THEME_RECIPE_META));
-
-export function resolveZoraThemeRecipe(
-  theme: ZoraThemeRecipeRuntimeTheme,
-  recipeName: string,
-): Readonly<Record<string, ThemeRecipeOverrideValue>> {
-  const meta = recipeMetaByName.get(recipeName);
-  if (!meta) throw new RangeError(`Unknown ZORA theme recipe: ${recipeName}.`);
-
-  const recipes =
-    meta.kind === 'component' ? theme.config.recipes?.components : theme.config.recipes?.patterns;
-  const overrides = new Map(Object.entries(recipes ?? {})).get(recipeName);
-  const overrideByField = new Map(Object.entries(overrides ?? {}));
-  const resolved: [string, ThemeRecipeOverrideValue][] = [];
-
-  for (const [fieldName, fieldMeta] of Object.entries(meta.fields)) {
-    const override = overrideByField.get(fieldName);
-    if (override !== undefined) {
-      validateFieldValue(theme, recipeName, fieldName, fieldMeta, override);
-      resolved.push([fieldName, override]);
-    } else if (fieldMeta.default !== undefined) {
-      resolved.push([fieldName, fieldMeta.default]);
-    }
-  }
-
-  return Object.fromEntries(resolved);
-}
-
-function validateFieldValue(
-  theme: ZoraThemeRecipeRuntimeTheme,
-  recipeName: string,
-  fieldName: string,
-  meta: ZoraThemeRecipeFieldMeta,
-  value: ThemeRecipeOverrideValue,
-): void {
-  if (meta.type === 'boolean') {
-    if (typeof value !== 'boolean') {
-      throw new TypeError(`Theme recipe ${recipeName}.${fieldName} must be boolean.`);
-    }
-    return;
-  }
-  if (typeof value !== 'string') {
-    throw new TypeError(`Theme recipe ${recipeName}.${fieldName} must be a string.`);
-  }
-  if (meta.type === 'choice' && !meta.options.includes(value)) {
-    throw new RangeError(`Invalid theme recipe choice for ${recipeName}.${fieldName}: ${value}.`);
-  }
-  if (meta.type === 'token' && !hasThemeToken(theme, meta.tokenFamily, value)) {
-    throw new RangeError(
-      `Unknown ${meta.tokenFamily} token for ${recipeName}.${fieldName}: ${value}.`,
-    );
-  }
-}
-
-function hasThemeToken(
-  theme: ZoraThemeRecipeRuntimeTheme,
-  family: ZoraThemeTokenFamily,
-  token: string,
-): boolean {
-  if (family === 'colors') return hasOwn(theme.colors, token);
-  if (family === 'spacing') return hasOwn(theme.spacing, token);
-  if (family === 'radii') return hasOwn(theme.radii, token);
-  if (family === 'shadows') return hasOwn(theme.shadows, token);
-  return (
-    hasOwn(theme.typography.sizes, token) ||
-    hasOwn(theme.typography.weights, token) ||
-    hasOwn(theme.typography.headings, token)
-  );
-}
-
-function hasOwn(value: object, key: PropertyKey): boolean {
-  return Object.prototype.hasOwnProperty.call(value, key);
-}

package/src/theme/themeConfigScope.test.ts

@@ -1,28 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-import { describe, expect, test } from 'bun:test';
-
-const themeDir = import.meta.dir;
-const srcDir = join(themeDir, '..');
-
-describe('canonical ThemeConfig scope propagation', () => {
-  test('provider accepts the canonical ThemeConfig without duplicating live config state', () => {
-    const provider = readFileSync(join(themeDir, 'ZoraProvider.tsx'), 'utf8');
-    const providerTypes = readFileSync(join(srcDir, 'types', 'provider.ts'), 'utf8');
-    const context = readFileSync(join(themeDir, 'ZoraThemeRuntimeContext.tsx'), 'utf8');
-
-    expect(providerTypes).toContain('themeConfig?: ThemeConfig');
-    expect(provider).toContain('themeConfig ?? createZoraThemeConfig(theme)');
-    expect(context).not.toContain('ThemeConfig');
-    expect(context).not.toContain('sourceTheme');
-  });
-
-  test('nested scopes derive from the current Surface config authority', () => {
-    const scope = readFileSync(join(themeDir, 'ZoraThemeScope.tsx'), 'utf8');
-    expect(scope).toContain('const sourceConfig = parentSurface.theme.config;');
-    expect(scope).toContain('createTheme(sourceConfig');
-    expect(scope).not.toContain('createZoraThemeConfig');
-    expect(scope).not.toContain('sourceTheme');
-  });
-});