react-native-terra-ui 0.10.1 → 0.11.0

package/src/utils/accent-utils.ts

@@ -1,13 +1,13 @@
 import { normalizeTokenOverride } from "#theme/legacy-tokens";
-import { normalizeAccentScheme } from "#theme/resolve-config";
+import { normalizeThemeScheme } from "#theme/resolve-config";
 import { defaultDarkTheme, defaultLightTheme } from "#theme/theme";
 import type {
-  Accent,
-  AccentSchemeInput,
+  NamedTheme,
   NormalizedAccent,
   Scheme,
   TerraTheme,
-  ThemeColor,
+  TerraThemeOverride,
+  ThemeSchemeInput,
 } from "#theme/types";
 import {
   ACCENT_SURFACE_ROLES,
@@ -30,31 +30,32 @@ export function defaultAccentContext(scheme: Scheme): AccentGenerationContext {
 }
 
 /**
- * Generated accent colours for `seed` with `overrides` applied last. Within
- * the override patch canonical names beat their legacy aliases, while an
- * alias-only key still beats the generated canonical value.
+ * Generate a palette using the named theme's ordinary surface overrides. The
+ * rest of the patch passes through as authored, matching the unseeded branch —
+ * so `spacing.base` / `radius.base` stay pseudo-tokens here; only
+ * `applyThemeLayer` expands them into a scale.
  */
 function seedToColorPatch(
   seed: string,
-  overrides: Partial<ThemeColor> | undefined,
+  patch: TerraThemeOverride | undefined,
   scheme: Scheme
 ): DeepPartial<TerraTheme> {
-  const generated = generateAccentColors(seed, defaultAccentContext(scheme)).colors;
-  const color: Record<string, string> = { ...generated };
-  const normalized = normalizeTokenOverride({ color: overrides })?.color;
-  if (normalized) {
-    for (const [key, value] of Object.entries(normalized)) {
-      if (value !== undefined) color[key] = value as string;
-    }
+  const normalized = normalizeTokenOverride(patch);
+  const context = defaultAccentContext(scheme);
+  for (const role of ACCENT_SURFACE_ROLES) {
+    const value = normalized?.color?.[role];
+    if (value !== undefined) context.surfaces[role] = value;
   }
-  return { color } as unknown as DeepPartial<TerraTheme>;
+  context.pressedOpacity = normalized?.opacity?.pressed ?? context.pressedOpacity;
+  const generated = generateAccentColors(seed, context).colors;
+  return { ...normalized, color: { ...generated, ...normalized?.color } } as DeepPartial<TerraTheme>;
 }
 
-function normalizeSchemeInput(input: AccentSchemeInput | undefined, scheme: Scheme): DeepPartial<TerraTheme> {
-  const normalized = normalizeAccentScheme(input, `accents.<accent>.${scheme}`);
+function normalizeSchemeInput(input: ThemeSchemeInput | undefined, scheme: Scheme): DeepPartial<TerraTheme> {
+  const normalized = normalizeThemeScheme(input, `themes.<name>.${scheme}`);
   if (normalized.kind === "none") return {};
   if (normalized.kind === "seed") {
-    return seedToColorPatch(normalized.seed, normalized.overrides, scheme);
+    return seedToColorPatch(normalized.seed, normalized.patch, scheme);
   }
   // Preserve the compatibility helper's identity contract for full patches;
   // the resolver itself uses the sanitized copy in `normalized.patch`.
@@ -62,13 +63,12 @@ function normalizeSchemeInput(input: AccentSchemeInput | undefined, scheme: Sche
 }
 
 /**
- * Compatibility wrapper: normalizes any accent input into per-scheme
- * partial-theme overrides. Strings and `{ seed, overrides }` are generated
- * against the DEFAULT themes' surfaces and pressed opacity (the resolver
- * pipeline uses the actual resolved surfaces instead); full theme patches
- * pass through unchanged. Pure and independent of the registry.
+ * @deprecated Prefer createTerraThemes for complete theme resolution.
+ * Generates per-scheme patches without shared config. Explicit unseeded patches
+ * pass through unchanged; seeded entries generate against their own surface and
+ * color tokens and carry the remainder of the patch through unresolved.
  */
-export function normalizeAccent(accent: Accent): NormalizedAccent {
+export function normalizeAccent(accent: NamedTheme): NormalizedAccent {
   return {
     light: normalizeSchemeInput(accent.light, "light"),
     dark: normalizeSchemeInput(accent.dark, "dark"),