react-native-terra-ui 0.10.2 → 0.11.1

package/src/theme/define-config.ts

@@ -1,7 +1,7 @@
 import type { TerraConfig } from "./types";
 
-/** The literal accent names declared in `T.accents`, or `never` when none are declared. */
-type DeclaredAccentNames<T> = T extends { accents: infer A }
+/** The literal theme names declared in `T.themes`, or `never` when none are declared. */
+type DeclaredThemeNames<T> = T extends { themes: infer A }
   ? A extends Record<string, unknown>
     ? keyof A & string
     : never
@@ -9,19 +9,24 @@ type DeclaredAccentNames<T> = T extends { accents: infer A }
 
 /**
  * Identity helper for authoring a {@link TerraConfig} with contextual typing.
- * Has no side effects. With literal `accents`, `defaultAccent` must name one of
- * them; a dynamic `Record<string, Accent>` keeps `defaultAccent` as `string`
+ * Has no side effects. With literal `themes`, `defaultTheme` must name one of
+ * them; a dynamic `Record<string, NamedTheme>` keeps `defaultTheme` as `string`
  * and defers to runtime validation.
  *
  * @example
  * const config = defineTerraConfig({
- *   accents: { indigo: { light: "#4f46e5", dark: "#818cf8" } },
- *   defaultAccent: "indigo",
+ *   themes: { indigo: { light: "#4f46e5", dark: "#818cf8" } },
+ *   defaultTheme: "indigo",
  * });
  * configureTerraUI(config);
  */
 export function defineTerraConfig<const T extends TerraConfig>(
-  config: T & { defaultAccent?: DeclaredAccentNames<T> }
+  config: T & {
+    defaultTheme?: DeclaredThemeNames<T>;
+    schemes?: never;
+    accents?: never;
+    defaultAccent?: never;
+  }
 ): T {
   return config;
 }

package/src/theme/errors.ts

@@ -1,7 +1,7 @@
 /**
  * Thrown for invalid pure configuration input — before any registry, selection,
  * or native state is touched. `path` points at the offending config entry, e.g.
- * `accents.indigo.dark.seed` or `defaultAccent`.
+ * `themes.indigo.dark.seed` or `defaultTheme`.
  */
 export class TerraConfigError extends Error {
   readonly path: string;

package/src/theme/index.ts

@@ -33,23 +33,23 @@ export { defineTerraConfig } from "./define-config";
 export { TerraConfigError } from "./errors";
 export {
   configureTerraUI,
-  getAccentNames,
   getDefaultRadius,
   getIcon,
   getImageComponent,
   getIsConfigured,
   getRequiredIcon,
   getSurfaceElevation,
+  getThemeNames,
   resolveTheme,
 } from "./registry";
 export { createTerraThemes } from "./resolve-config";
 export type { ThemeSelection } from "./runtime";
 export {
-  applyAccent,
   applyScheme,
-  getCurrentAccent,
+  getCurrentTheme,
   getThemeMode,
   getThemeSelection,
+  setTheme,
   setThemeMode,
 } from "./runtime";
 export type { ResolvedScreenMargin } from "./screen-margin";
@@ -60,12 +60,7 @@ export { resolveScreenPadding } from "./screen-padding";
 export { defaultDarkTheme, defaultLightTheme } from "./theme";
 // ─── Types ────────────────────────────────────────────────────────────────────
 export type {
-  Accent,
   AccentColorToken,
-  AccentOverride,
-  AccentSchemeInput,
-  AccentSeed,
-  AccentShorthand,
   ActionColorToken,
   BackgroundColorToken,
   BorderColorToken,
@@ -81,6 +76,7 @@ export type {
   ElevationStyle,
   FontWeightToken,
   LayoutTokens,
+  NamedTheme,
   NeutralColorToken,
   OpacityTokens,
   RadiusComponent,
@@ -110,6 +106,8 @@ export type {
   ThemeColor,
   ThemeMode,
   ThemeRadiusOverride,
+  ThemeSchemeInput,
+  ThemeSeed,
   ThemeSpacingOverride,
   TypeStyle,
   Typography,

package/src/theme/registry.ts

@@ -23,7 +23,6 @@ import type {
   TerraImageComponent,
   TerraSemanticIconName,
   TerraTheme,
-  TerraThemeInput,
   ThemeMode,
 } from "./types";
 import { applyMode, configureUnistyles, hasConfiguredUnistyles, updateThemes } from "./unistyles-adapter";
@@ -81,8 +80,8 @@ let installation: "unconfigured" | "fallback" | "app" = "unconfigured";
 
 export const getIsConfigured = (): boolean => installation !== "unconfigured";
 
-/** Names of the registered accents, in declaration order. Returns a fresh array. */
-export const getAccentNames = (): string[] => [...getInstalledConfig().accentNames];
+/** Names of the registered themes, in declaration order. Returns a fresh array. */
+export const getThemeNames = (): string[] => [...getInstalledConfig().themeNames];
 
 export const getImageComponent = (): TerraImageComponent => settings.imageComponent;
 
@@ -107,22 +106,22 @@ export const getSurfaceElevation = (): ElevationKey => settings.surfaceElevation
 
 /**
  * Resolves one scheme's theme from the installed configuration with the named
- * accent overlaid. Omitting `accentName` selects the base theme (no accent —
- * not the configured `defaultAccent`). An unknown name warns in development
+ * theme selected. Omitting `name` selects the base theme (defaults + shared —
+ * not the configured `defaultTheme`). An unknown name warns in development
  * and falls back to the base theme. Pure with respect to runtime state: it
  * never changes the applied selection.
  */
-export function resolveTheme(scheme: Scheme, accentName?: string): TerraTheme {
+export function resolveTheme(scheme: Scheme, name?: string): TerraTheme {
   const config = getInstalledConfig();
-  let accent: string | null = null;
-  if (accentName !== undefined) {
-    if (config.accentNames.includes(accentName)) {
-      accent = accentName;
+  let themeName: string | null = null;
+  if (name !== undefined) {
+    if (config.themeNames.includes(name)) {
+      themeName = name;
     } else if (__DEV__) {
-      console.warn(`[react-native-terra-ui] Unknown accent "${accentName}"; resolving the base theme.`);
+      console.warn(`[react-native-terra-ui] Unknown theme "${name}"; resolving the base theme.`);
     }
   }
-  return resolveThemeScheme(config, scheme, accent).theme;
+  return resolveThemeScheme(config, scheme, themeName).theme;
 }
 
 // ─── Configuration ───────────────────────────────────────────────────────────
@@ -189,22 +188,15 @@ function deriveMode(config: TerraConfig): ThemeMode {
   return "system";
 }
 
-const pickThemeInput = (config: TerraConfig): TerraThemeInput => ({
-  shared: config.shared,
-  schemes: config.schemes,
-  accents: config.accents,
-  defaultAccent: config.defaultAccent,
-});
-
 function applyConfig(config: TerraConfig, kind: "fallback" | "app"): void {
   // (a) Pure: validate and build everything. Throws leave ALL state untouched.
-  const themeConfig = normalizeThemeInput(pickThemeInput(config));
+  const themeConfig = normalizeThemeInput(config);
   const mode = deriveMode(config);
-  const { themes, diagnostics } = resolveThemes(themeConfig, themeConfig.defaultAccent);
+  const { themes, diagnostics } = resolveThemes(themeConfig, themeConfig.defaultTheme);
   const nextSettings = buildSettings(config);
 
   // (b) Native. `StyleSheet.configure` runs once per app; after that the
-  // rebuilt themes reach the runtime the same way an accent change does, so an
+  // rebuilt themes reach the runtime the same way a theme change does, so an
   // app's config is never stranded behind the fallback's defaults.
   if (hasConfiguredUnistyles()) {
     updateThemes(themes);
@@ -217,7 +209,7 @@ function applyConfig(config: TerraConfig, kind: "fallback" | "app"): void {
   installation = kind;
   settings = nextSettings;
   setInstalledConfig(themeConfig);
-  publishThemeSelection({ accent: themeConfig.defaultAccent ?? undefined, mode });
+  publishThemeSelection({ themeName: themeConfig.defaultTheme ?? undefined, mode });
 
   warnContrastDiagnostics(diagnostics);
 }

package/src/theme/resolve-config.ts

@@ -1,12 +1,12 @@
 /**
  * Pure theme resolution — normalization, layer processing, derived values and
- * theme creation. Shared by startup configuration, runtime accent changes and
+ * theme creation. Shared by startup configuration, runtime theme changes and
  * previews so every consumer sees the same colors for the same input.
  *
  * Precedence, identical for both schemes:
  *
- *   default tokens → shared → schemes[scheme]
- *       → generated selected accent → selected accent explicit overrides
+ *   default tokens → shared → generated accent → selected theme tokens
+ * Generation uses the selected theme's resolved surfaces and pressed opacity.
  *
  * This module must stay free of registry, provider, Unistyles and renderer
  * imports so `createTerraThemes` works without any native configuration.
@@ -33,15 +33,14 @@ import {
   type ThemeSource,
 } from "./theme";
 import type {
-  Accent,
-  AccentSchemeInput,
   CreateTerraThemesOptions,
   ElevationKey,
+  NamedTheme,
   Scheme,
   TerraTheme,
   TerraThemeInput,
   TerraThemeOverride,
-  ThemeColor,
+  ThemeSchemeInput,
 } from "./types";
 
 const SCHEMES: readonly Scheme[] = ["light", "dark"];
@@ -87,8 +86,8 @@ function sanitizeOverride<T>(value: T): T {
 
 /**
  * Applies one override layer onto `state` and returns the next state. Every
- * layer — shared, scheme, generated accent, accent overrides, or a full accent
- * patch — goes through here, so they all follow the same rules:
+ * layer — shared, generated accent, or selected theme tokens — goes through
+ * here, so they all follow the same rules:
  * - deprecated names are normalized within the layer (canonical wins);
  * - `undefined`/`null` leaves are no override; arrays replace; objects merge;
  * - `spacing.base` / `radius.base` regenerate their scale, then that layer's
@@ -140,34 +139,34 @@ export function applyThemeLayer(state: ThemeLayerState, override?: TerraThemeOve
 
 // ─── Normalized configuration ────────────────────────────────────────────────
 
-export type NormalizedAccentScheme =
+export type NormalizedThemeScheme =
   | { readonly kind: "none" }
-  | { readonly kind: "seed"; readonly seed: string; readonly overrides?: Partial<ThemeColor> }
+  | { readonly kind: "seed"; readonly seed: string; readonly patch?: TerraThemeOverride }
   | { readonly kind: "patch"; readonly patch: TerraThemeOverride };
 
-interface NormalizedAccentEntry {
-  readonly light: NormalizedAccentScheme;
-  readonly dark: NormalizedAccentScheme;
+interface NormalizedThemeEntry {
+  readonly light: NormalizedThemeScheme;
+  readonly dark: NormalizedThemeScheme;
 }
 
 /**
  * A validated, immutable theme configuration. `base` is the fully layered
- * `defaults → shared → scheme` state per scheme; every accent selection is
- * re-resolved from it rather than from a previously resolved accent.
+ * `defaults → shared` state per scheme; every theme selection is
+ * re-resolved from it rather than from a previously resolved theme.
  */
 export interface NormalizedThemeConfig {
-  readonly accentNames: readonly string[];
-  readonly defaultAccent: string | null;
-  /** @internal Immutable `defaults → shared → scheme` state per scheme. */
+  readonly themeNames: readonly string[];
+  readonly defaultTheme: string | null;
+  /** @internal Immutable `defaults → shared` state per scheme. */
   readonly base: Readonly<Record<Scheme, ThemeLayerState>>;
-  /** @internal Per-accent, per-scheme normalized inputs. */
-  readonly accents: Readonly<Record<string, NormalizedAccentEntry>>;
+  /** @internal Per-theme, per-scheme normalized inputs. */
+  readonly themes: Readonly<Record<string, NormalizedThemeEntry>>;
 }
 
-export function normalizeAccentScheme(
-  input: AccentSchemeInput | undefined,
+export function normalizeThemeScheme(
+  input: ThemeSchemeInput | undefined,
   path: string
-): NormalizedAccentScheme {
+): NormalizedThemeScheme {
   if (input === undefined || input === null) return { kind: "none" };
 
   if (typeof input === "string") {
@@ -183,52 +182,46 @@ export function normalizeAccentScheme(
   if (!isPlainObject(input)) {
     throw new TerraConfigError(
       path,
-      "Expected a color string, `{ seed, overrides }`, or a theme override object."
+      "Expected a color string, `{ seed, color }`, or a theme override object."
     );
   }
 
-  if (!("seed" in input)) {
-    return { kind: "patch", patch: sanitizeOverride(input as TerraThemeOverride) };
+  if ("overrides" in input) {
+    throw new TerraConfigError(`${path}.overrides`, "Use `color` for explicit colors alongside `seed`.");
   }
-
-  const extra = Object.keys(input).filter((key) => key !== "seed" && key !== "overrides");
-  if (extra.length > 0) {
-    throw new TerraConfigError(
-      path,
-      `A seeded accent accepts only \`seed\` and \`overrides\`; found ${extra
-        .map((key) => `\`${key}\``)
-        .join(
-          ", "
-        )}. Use \`{ seed, overrides: { ... } }\` for color exceptions, or drop \`seed\` for a full theme override.`
-    );
+  const { seed, ...patch } = input as TerraThemeOverride & { seed?: unknown };
+  assertOverrideObject(patch.color, `${path}.color`);
+  if (!("seed" in input)) {
+    return { kind: "patch", patch: sanitizeOverride(patch) };
   }
-
-  const { seed, overrides } = input as { seed: unknown; overrides?: unknown };
   if (!isSupportedAccentSeed(seed)) {
     throw new TerraConfigError(
       `${path}.seed`,
       `Unsupported accent seed ${JSON.stringify(seed)}; expected an opaque six-digit hex color (#rrggbb).`
     );
   }
-  if (overrides !== undefined && !isPlainObject(overrides)) {
-    throw new TerraConfigError(`${path}.overrides`, "Expected a flat semantic color patch object.");
-  }
-
-  return {
-    kind: "seed",
-    seed: seed.trim(),
-    ...(overrides ? { overrides: sanitizeOverride(overrides as Partial<ThemeColor>) } : {}),
-  };
+  return { kind: "seed", seed: seed.trim(), patch: sanitizeOverride(patch) };
 }
 
-function normalizeAccentEntry(name: string, accent: Accent): NormalizedAccentEntry {
-  const path = `accents.${name}`;
-  if (!isPlainObject(accent)) {
+function normalizeThemeEntry(name: string, theme: NamedTheme): NormalizedThemeEntry {
+  const path = `themes.${name}`;
+  if (!isPlainObject(theme)) {
     throw new TerraConfigError(path, "Expected an object with `light` and/or `dark` scheme inputs.");
   }
+  // An empty entry is a valid theme that adds nothing, but tokens sitting
+  // outside a scheme — `{ seed, color }` lifted straight out of the old
+  // `accents` shape — would otherwise be accepted and silently render defaults.
+  const keys = Object.keys(theme);
+  if (keys.length > 0 && !("light" in theme) && !("dark" in theme)) {
+    throw new TerraConfigError(
+      path,
+      `Unexpected ${keys.map((key) => `\`${key}\``).join(", ")} outside a scheme; ` +
+        "put `seed` and token overrides under `light` and/or `dark`."
+    );
+  }
   return {
-    light: normalizeAccentScheme(accent.light, `${path}.light`),
-    dark: normalizeAccentScheme(accent.dark, `${path}.dark`),
+    light: normalizeThemeScheme(theme.light, `${path}.light`),
+    dark: normalizeThemeScheme(theme.dark, `${path}.dark`),
   };
 }
 
@@ -240,7 +233,7 @@ function assertOverrideObject(value: unknown, path: string): void {
 
 /**
  * Validates a theme input and pre-computes the immutable per-scheme base
- * (`defaults → shared → scheme`). Throws {@link TerraConfigError} for invalid
+ * (`defaults → shared`). Throws {@link TerraConfigError} for invalid
  * input — before any state exists to mutate. Never mutates `input` or the
  * exported defaults.
  */
@@ -250,41 +243,42 @@ export function normalizeThemeInput(input: TerraThemeInput = {}): NormalizedThem
   }
 
   assertOverrideObject(input.shared, "shared");
-  assertOverrideObject(input.schemes, "schemes");
-  assertOverrideObject(input.schemes?.light, "schemes.light");
-  assertOverrideObject(input.schemes?.dark, "schemes.dark");
-  if (input.accents !== undefined && !isPlainObject(input.accents)) {
-    throw new TerraConfigError("accents", "Expected a record of named accents.");
+  for (const removed of ["schemes", "accents", "defaultAccent"]) {
+    if (removed in input) {
+      throw new TerraConfigError(removed, "Use `themes.<name>.light/dark` and `defaultTheme` instead.");
+    }
+  }
+  if (input.themes !== undefined && !isPlainObject(input.themes)) {
+    throw new TerraConfigError("themes", "Expected a record of named themes.");
   }
 
-  const accents: Record<string, NormalizedAccentEntry> = {};
-  for (const [name, accent] of Object.entries(input.accents ?? {})) {
-    accents[name] = normalizeAccentEntry(name, accent);
+  const themes: Record<string, NormalizedThemeEntry> = Object.create(null);
+  for (const [name, theme] of Object.entries(input.themes ?? {})) {
+    themes[name] = normalizeThemeEntry(name, theme);
   }
-  const accentNames = Object.keys(accents);
+  const themeNames = Object.keys(themes);
 
-  let defaultAccent: string | null = null;
-  if (input.defaultAccent !== undefined && input.defaultAccent !== null) {
-    if (typeof input.defaultAccent !== "string" || !Object.hasOwn(accents, input.defaultAccent)) {
+  let defaultTheme: string | null = null;
+  if (input.defaultTheme !== undefined && input.defaultTheme !== null) {
+    if (typeof input.defaultTheme !== "string" || !Object.hasOwn(themes, input.defaultTheme)) {
       throw new TerraConfigError(
-        "defaultAccent",
-        `Unknown accent ${JSON.stringify(input.defaultAccent)}; declared accents: ${
-          accentNames.length > 0 ? accentNames.map((n) => `"${n}"`).join(", ") : "(none)"
+        "defaultTheme",
+        `Unknown theme ${JSON.stringify(input.defaultTheme)}; declared themes: ${
+          themeNames.length > 0 ? themeNames.map((n) => `"${n}"`).join(", ") : "(none)"
         }.`
       );
     }
-    defaultAccent = input.defaultAccent;
+    defaultTheme = input.defaultTheme;
   }
 
   const base = {} as Record<Scheme, ThemeLayerState>;
   for (const scheme of SCHEMES) {
     let state: ThemeLayerState = { source: createDefaultThemeSource(scheme), pinnedShadowColors: {} };
     state = applyThemeLayer(state, input.shared);
-    state = applyThemeLayer(state, input.schemes?.[scheme]);
     base[scheme] = state;
   }
 
-  return { accentNames, defaultAccent, base, accents };
+  return { themeNames, defaultTheme, base, themes };
 }
 
 // ─── Resolution ──────────────────────────────────────────────────────────────
@@ -295,19 +289,19 @@ export interface ResolvedThemes {
   diagnostics: ContrastDiagnostic[];
 }
 
-function getAccentEntry(
+function getThemeEntry(
   config: NormalizedThemeConfig,
-  accent: string | null
-): NormalizedAccentEntry | undefined {
-  if (accent === null) return undefined;
+  themeName: string | null
+): NormalizedThemeEntry | undefined {
+  if (themeName === null) return undefined;
 
-  const entry = config.accents[accent];
-  if (entry) return entry;
+  const entry = config.themes[themeName];
+  if (Object.hasOwn(config.themes, themeName)) return entry;
 
   throw new TerraConfigError(
-    "accent",
-    `Unknown accent ${JSON.stringify(accent)}; declared accents: ${
-      config.accentNames.length > 0 ? config.accentNames.map((name) => `"${name}"`).join(", ") : "(none)"
+    "theme",
+    `Unknown theme ${JSON.stringify(themeName)}; declared themes: ${
+      config.themeNames.length > 0 ? config.themeNames.map((name) => `"${name}"`).join(", ") : "(none)"
     }.`
   );
 }
@@ -331,7 +325,7 @@ function pickGeneratedRoles(color: ThemeSource["color"]): Record<GeneratedAccent
 function resolveScheme(
   scheme: Scheme,
   base: ThemeLayerState,
-  accent: NormalizedAccentScheme
+  accent: NormalizedThemeScheme
 ): { theme: TerraTheme; diagnostics: ContrastDiagnostic[] } {
   let state = base;
   let diagnostics: ContrastDiagnostic[] = [];
@@ -339,12 +333,11 @@ function resolveScheme(
   if (accent.kind === "patch") {
     state = applyThemeLayer(state, accent.patch);
   } else if (accent.kind === "seed") {
-    const context = accentContext(scheme, state.source);
+    // Generate against the final ordinary surfaces, then let explicit tokens win.
+    const context = accentContext(scheme, applyThemeLayer(base, accent.patch).source);
     const generated = generateAccentColors(accent.seed, context);
     state = applyThemeLayer(state, { color: generated.colors } as TerraThemeOverride);
-    if (accent.overrides) {
-      state = applyThemeLayer(state, { color: accent.overrides });
-    }
+    state = applyThemeLayer(state, accent.patch);
     // The post-override check is authoritative: it evaluates the colours that
     // actually ship, so an override that fixes a pair leaves no stale report.
     diagnostics = checkAccentContrast(
@@ -357,12 +350,12 @@ function resolveScheme(
 }
 
 /**
- * Resolves both schemes for `accent` from the config's immutable base. `null`
+ * Resolves both schemes for `themeName` from the config's immutable base. `null`
  * selects the base themes; an unknown name throws {@link TerraConfigError}.
  * Returned themes are freshly built and independently owned.
  */
-export function resolveThemes(config: NormalizedThemeConfig, accent: string | null): ResolvedThemes {
-  const entry = getAccentEntry(config, accent);
+export function resolveThemes(config: NormalizedThemeConfig, themeName: string | null): ResolvedThemes {
+  const entry = getThemeEntry(config, themeName);
 
   const themes = {} as Record<Scheme, TerraTheme>;
   const diagnostics: ContrastDiagnostic[][] = [];
@@ -379,16 +372,16 @@ export function resolveThemes(config: NormalizedThemeConfig, accent: string | nu
 export function resolveThemeScheme(
   config: NormalizedThemeConfig,
   scheme: Scheme,
-  accent: string | null
+  themeName: string | null
 ): { theme: TerraTheme; diagnostics: ContrastDiagnostic[] } {
-  const entry = getAccentEntry(config, accent);
+  const entry = getThemeEntry(config, themeName);
   return resolveScheme(scheme, config.base[scheme], entry?.[scheme] ?? { kind: "none" });
 }
 
 /**
  * Pure theme creation — no Unistyles configuration or registry involved.
- * `options.accent` omitted → the input's `defaultAccent`; `null` → the base
- * themes. Invalid input and unknown accents throw {@link TerraConfigError}.
+ * `options.theme` omitted → the input's `defaultTheme`; `null` → the base
+ * themes. Invalid input and unknown themes throw {@link TerraConfigError}.
  * In development, contrast diagnostics are reported once each via
  * `console.warn`; requested colors are never altered.
  */
@@ -397,8 +390,8 @@ export function createTerraThemes(
   options?: CreateTerraThemesOptions
 ): Record<Scheme, TerraTheme> {
   const config = normalizeThemeInput(input);
-  const accent = options?.accent === undefined ? config.defaultAccent : options.accent;
-  const { themes, diagnostics } = resolveThemes(config, accent);
+  const themeName = options?.theme === undefined ? config.defaultTheme : options.theme;
+  const { themes, diagnostics } = resolveThemes(config, themeName);
 
   warnContrastDiagnostics(diagnostics);
 

package/src/theme/runtime.ts

@@ -1,9 +1,9 @@
 /**
- * Runtime selection commands — accent and theme mode — plus the subscribed
+ * Runtime selection commands — theme and theme mode — plus the subscribed
  * selection snapshot consumed by `useTheme()`.
  *
- * Every accent change re-resolves both schemes from the installed, immutable
- * configuration (never from the previously resolved accent), hands them to
+ * Every theme change re-resolves both schemes from the installed, immutable
+ * configuration (never from the previously resolved theme), hands them to
  * Unistyles, and only then publishes the new selection. A rejected or failed
  * change leaves both the native themes and the published selection untouched.
  */
@@ -17,30 +17,30 @@ export type { ThemeSelection } from "./selection-store";
 export { getThemeSelection, subscribeThemeSelection } from "./selection-store";
 
 /**
- * Apply a registered accent (`null` restores the base themes) by updating both
+ * Apply a registered theme (`null` restores the base themes) by updating both
  * registered themes. An unknown name warns in development and changes nothing.
  *
  * If the native update fails part-way (see `updateThemes` in the adapter), the
  * error propagates and the previous selection stays published; calling
- * `applyAccent(getCurrentAccent() ?? null)` rewrites both themes.
+ * `setTheme(getCurrentTheme() ?? null)` rewrites both themes.
  */
-export function applyAccent(name: string | null): void {
+export function setTheme(name: string | null): void {
   const config = getInstalledConfig();
-  if (name !== null && !config.accentNames.includes(name)) {
+  if (name !== null && !config.themeNames.includes(name)) {
     if (__DEV__) {
-      console.warn(`[react-native-terra-ui] Unknown accent "${name}".`);
+      console.warn(`[react-native-terra-ui] Unknown theme "${name}".`);
     }
     return;
   }
 
   const { themes, diagnostics } = resolveThemes(config, name);
   updateThemes(themes);
-  publishThemeSelection({ accent: name ?? undefined });
+  publishThemeSelection({ themeName: name ?? undefined });
   warnContrastDiagnostics(diagnostics);
 }
 
-/** The applied accent name, or `undefined` for the base themes. */
-export const getCurrentAccent = (): string | undefined => getThemeSelection().accent;
+/** The applied theme name, or `undefined` for the base themes. */
+export const getCurrentTheme = (): string | undefined => getThemeSelection().themeName;
 
 /**
  * Choose how the active scheme is selected: `system` follows the OS appearance;

package/src/theme/selection-store.ts

@@ -4,9 +4,9 @@
  * those has to import the other.
  *
  * Holds two things, both private to `theme/`:
- * - the installed {@link NormalizedThemeConfig} — immutable; every accent
+ * - the installed {@link NormalizedThemeConfig} — immutable; every theme
  *   selection is re-resolved from it, never layered on a previous result;
- * - the selection snapshot (`accent`, `mode`) behind a `useSyncExternalStore`
+ * - the selection snapshot (`themeName`, `mode`) behind a `useSyncExternalStore`
  *   compatible subscribe/get pair. The snapshot object keeps its identity until
  *   a value actually changes, so subscribers only re-render on real changes.
  *
@@ -33,15 +33,15 @@ export function setInstalledConfig(config: NormalizedThemeConfig): void {
 
 // ─── Selection snapshot ──────────────────────────────────────────────────────
 
-/** The current runtime selection: which accent is applied and how the scheme is chosen. */
+/** The current runtime selection: which theme is applied and how the scheme is chosen. */
 export interface ThemeSelection {
-  /** Applied accent name, or `undefined` for the base themes. */
-  readonly accent: string | undefined;
+  /** Applied theme name, or `undefined` for the base themes. */
+  readonly themeName: string | undefined;
   /** `system` follows the OS appearance; `light` / `dark` pin a scheme. */
   readonly mode: ThemeMode;
 }
 
-let selection: ThemeSelection = Object.freeze({ accent: undefined, mode: "system" as ThemeMode });
+let selection: ThemeSelection = Object.freeze({ themeName: undefined, mode: "system" as ThemeMode });
 
 const listeners = new Set<() => void>();
 
@@ -65,11 +65,11 @@ export function subscribeThemeSelection(listener: () => void): () => void {
  * A no-op — same snapshot identity, no notification — when nothing changed.
  */
 export function publishThemeSelection(next: Partial<ThemeSelection>): void {
-  const accent = "accent" in next ? next.accent : selection.accent;
+  const themeName = "themeName" in next ? next.themeName : selection.themeName;
   const mode = next.mode ?? selection.mode;
-  if (accent === selection.accent && mode === selection.mode) return;
+  if (themeName === selection.themeName && mode === selection.mode) return;
 
-  selection = Object.freeze({ accent, mode });
+  selection = Object.freeze({ themeName, mode });
   for (const listener of listeners) {
     listener();
   }