react-native-terra-ui 0.7.1 → 0.8.0

package/src/theme/legacy-tokens.ts

@@ -0,0 +1,227 @@
+import { deepMerge } from "#utils/deep-merge";
+import type { CanonicalThemeColor, TerraTheme, TerraThemeOverride } from "./types";
+
+/** Legacy color names. Explicit action/status-property aliases come first to resolve synonyms. */
+export const legacyColorAliases = {
+  "action.bg.primary": "accent.solid.bg",
+  "action.bg.primary.active": "accent.solid.bg.pressed",
+  "action.bg.primary.disabled": "accent.solid.bg.disabled",
+  "action.bg.primary.hover": "accent.solid.bg.hover",
+  "action.bg.primary.subtle": "accent.soft.bg",
+  "action.bg.primary.subtle.active": "accent.soft.bg.pressed",
+  "action.bg.primary.subtle.disabled": "accent.soft.bg.disabled",
+  "action.bg.primary.subtle.hover": "accent.soft.bg.hover",
+  "action.bg.secondary": "neutral.solid.bg",
+  "action.bg.secondary.subtle": "neutral.soft.bg",
+  "action.bg.secondary.subtle.active": "neutral.soft.bg.pressed",
+  "action.bg.secondary.subtle.disabled": "neutral.soft.bg.disabled",
+  "action.bg.secondary.subtle.hover": "neutral.soft.bg.hover",
+  "action.fg.primary": "accent.solid.fg",
+  "action.fg.primary.subtle": "accent.soft.fg",
+  "action.fg.secondary": "neutral.solid.fg",
+  "action.fg.secondary.subtle": "neutral.soft.fg",
+  "status.danger.bg": "danger.solid.bg",
+  "status.danger.bg.subtle": "danger.soft.bg",
+  "status.danger.border": "danger.solid.border",
+  "status.danger.border.subtle": "danger.soft.border",
+  "status.danger.fg": "danger.solid.fg",
+  "status.danger.fg.subtle": "danger.soft.fg",
+  "status.info.bg": "info.solid.bg",
+  "status.info.bg.subtle": "info.soft.bg",
+  "status.info.border": "info.solid.border",
+  "status.info.border.subtle": "info.soft.border",
+  "status.info.fg": "info.solid.fg",
+  "status.info.fg.subtle": "info.soft.fg",
+  "status.success.bg": "success.solid.bg",
+  "status.success.bg.subtle": "success.soft.bg",
+  "status.success.border": "success.solid.border",
+  "status.success.border.subtle": "success.soft.border",
+  "status.success.fg": "success.solid.fg",
+  "status.success.fg.subtle": "success.soft.fg",
+  "status.warning.bg": "warning.solid.bg",
+  "status.warning.bg.subtle": "warning.soft.bg",
+  "status.warning.border": "warning.solid.border",
+  "status.warning.border.subtle": "warning.soft.border",
+  "status.warning.fg": "warning.solid.fg",
+  "status.warning.fg.subtle": "warning.soft.fg",
+  "background": "surface.canvas",
+  "border.accent": "accent.border",
+  "border.focus": "focus.ring",
+  "status.danger": "danger.solid.bg",
+  "status.info": "info.solid.bg",
+  "status.success": "success.solid.bg",
+  "status.warning": "warning.solid.bg",
+  "surface.accent": "accent.solid.bg",
+  "surface.accent.subtle": "accent.soft.bg",
+  "surface.overlay": "backdrop",
+  "text.accent": "accent.text",
+  "text.default": "text.primary",
+  "text.muted": "text.secondary",
+  "text.on-accent": "accent.solid.fg",
+  "text.on-accent-subtle": "accent.soft.fg",
+  "text.subtle": "text.tertiary",
+} as const satisfies Record<keyof LegacyThemeColor, keyof CanonicalThemeColor>;
+
+export interface LegacyThemeColor {
+  /** @deprecated Use `accent.solid.bg`. */
+  "action.bg.primary": string;
+  /** @deprecated Use `accent.solid.bg.pressed`. */
+  "action.bg.primary.active": string;
+  /** @deprecated Use `accent.solid.bg.disabled`. */
+  "action.bg.primary.disabled": string;
+  /** @deprecated Use `accent.solid.bg.hover`. */
+  "action.bg.primary.hover": string;
+  /** @deprecated Use `accent.soft.bg`. */
+  "action.bg.primary.subtle": string;
+  /** @deprecated Use `accent.soft.bg.pressed`. */
+  "action.bg.primary.subtle.active": string;
+  /** @deprecated Use `accent.soft.bg.disabled`. */
+  "action.bg.primary.subtle.disabled": string;
+  /** @deprecated Use `accent.soft.bg.hover`. */
+  "action.bg.primary.subtle.hover": string;
+  /** @deprecated Use `neutral.solid.bg`. */
+  "action.bg.secondary": string;
+  /** @deprecated Use `neutral.soft.bg`. */
+  "action.bg.secondary.subtle": string;
+  /** @deprecated Use `neutral.soft.bg.pressed`. */
+  "action.bg.secondary.subtle.active": string;
+  /** @deprecated Use `neutral.soft.bg.disabled`. */
+  "action.bg.secondary.subtle.disabled": string;
+  /** @deprecated Use `neutral.soft.bg.hover`. */
+  "action.bg.secondary.subtle.hover": string;
+  /** @deprecated Use `accent.solid.fg`. */
+  "action.fg.primary": string;
+  /** @deprecated Use `accent.soft.fg`. */
+  "action.fg.primary.subtle": string;
+  /** @deprecated Use `neutral.solid.fg`. */
+  "action.fg.secondary": string;
+  /** @deprecated Use `neutral.soft.fg`. */
+  "action.fg.secondary.subtle": string;
+  /** @deprecated Use `danger.solid.bg`. */
+  "status.danger.bg": string;
+  /** @deprecated Use `danger.soft.bg`. */
+  "status.danger.bg.subtle": string;
+  /** @deprecated Use `danger.solid.border`. */
+  "status.danger.border": string;
+  /** @deprecated Use `danger.soft.border`. */
+  "status.danger.border.subtle": string;
+  /** @deprecated Use `danger.solid.fg`. */
+  "status.danger.fg": string;
+  /** @deprecated Use `danger.soft.fg`. */
+  "status.danger.fg.subtle": string;
+  /** @deprecated Use `info.solid.bg`. */
+  "status.info.bg": string;
+  /** @deprecated Use `info.soft.bg`. */
+  "status.info.bg.subtle": string;
+  /** @deprecated Use `info.solid.border`. */
+  "status.info.border": string;
+  /** @deprecated Use `info.soft.border`. */
+  "status.info.border.subtle": string;
+  /** @deprecated Use `info.solid.fg`. */
+  "status.info.fg": string;
+  /** @deprecated Use `info.soft.fg`. */
+  "status.info.fg.subtle": string;
+  /** @deprecated Use `success.solid.bg`. */
+  "status.success.bg": string;
+  /** @deprecated Use `success.soft.bg`. */
+  "status.success.bg.subtle": string;
+  /** @deprecated Use `success.solid.border`. */
+  "status.success.border": string;
+  /** @deprecated Use `success.soft.border`. */
+  "status.success.border.subtle": string;
+  /** @deprecated Use `success.solid.fg`. */
+  "status.success.fg": string;
+  /** @deprecated Use `success.soft.fg`. */
+  "status.success.fg.subtle": string;
+  /** @deprecated Use `warning.solid.bg`. */
+  "status.warning.bg": string;
+  /** @deprecated Use `warning.soft.bg`. */
+  "status.warning.bg.subtle": string;
+  /** @deprecated Use `warning.solid.border`. */
+  "status.warning.border": string;
+  /** @deprecated Use `warning.soft.border`. */
+  "status.warning.border.subtle": string;
+  /** @deprecated Use `warning.solid.fg`. */
+  "status.warning.fg": string;
+  /** @deprecated Use `warning.soft.fg`. */
+  "status.warning.fg.subtle": string;
+  /** @deprecated Use `surface.canvas`. */
+  "background": string;
+  /** @deprecated Use `accent.border`. */
+  "border.accent": string;
+  /** @deprecated Use `focus.ring`. */
+  "border.focus": string;
+  /** @deprecated Use `danger.solid.bg`. */
+  "status.danger": string;
+  /** @deprecated Use `info.solid.bg`. */
+  "status.info": string;
+  /** @deprecated Use `success.solid.bg`. */
+  "status.success": string;
+  /** @deprecated Use `warning.solid.bg`. */
+  "status.warning": string;
+  /** @deprecated Use `accent.solid.bg`. */
+  "surface.accent": string;
+  /** @deprecated Use `accent.soft.bg`. */
+  "surface.accent.subtle": string;
+  /** @deprecated Use `backdrop`. */
+  "surface.overlay": string;
+  /** @deprecated Use `accent.text`. */
+  "text.accent": string;
+  /** @deprecated Use `text.primary`. */
+  "text.default": string;
+  /** @deprecated Use `text.secondary`. */
+  "text.muted": string;
+  /** @deprecated Use `accent.solid.fg`. */
+  "text.on-accent": string;
+  /** @deprecated Use `accent.soft.fg`. */
+  "text.on-accent-subtle": string;
+  /** @deprecated Use `text.tertiary`. */
+  "text.subtle": string;
+}
+
+/** Normalize each authored layer before merging, so aliases respect layer precedence. */
+export function normalizeTokenOverride(override?: TerraThemeOverride): TerraThemeOverride | undefined {
+  if (!override) return override;
+  const next = { ...override };
+  if (override.color) {
+    const color = { ...override.color };
+    for (const [legacy, canonical] of Object.entries(legacyColorAliases)) {
+      const value = override.color[legacy as keyof LegacyThemeColor];
+      if (color[canonical] === undefined && value !== undefined) color[canonical] = value;
+      delete color[legacy as keyof LegacyThemeColor];
+    }
+    next.color = color;
+  }
+  const screen = override.layout?.screen;
+  if (screen) {
+    const { margin, padding, ...rest } = screen;
+    next.layout = {
+      ...override.layout,
+      screen: { ...rest, padding: deepMerge(margin ?? {}, padding) },
+    };
+  }
+  return next;
+}
+
+/** Materialize aliases for direct theme reads as well as component color props. */
+export function withLegacyTokens(
+  theme: Omit<TerraTheme, "color" | "layout"> & {
+    color: CanonicalThemeColor;
+    layout: Omit<TerraTheme["layout"], "screen"> & {
+      screen: Pick<TerraTheme["layout"]["screen"], "padding">;
+    };
+  }
+): TerraTheme {
+  const color = { ...theme.color } as TerraTheme["color"];
+  for (const [legacy, canonical] of Object.entries(legacyColorAliases)) {
+    color[legacy as keyof LegacyThemeColor] = color[canonical];
+  }
+  return {
+    ...theme,
+    color,
+    layout: {
+      ...theme.layout,
+      screen: { ...theme.layout.screen, margin: theme.layout.screen.padding },
+    },
+  };
+}

package/src/theme/registry.ts

@@ -1,16 +1,21 @@
-import { StyleSheet, UnistylesRuntime } from "react-native-unistyles";
-
-import { normalizeAccent } from "#utils/accent-utils";
-import { deepMerge } from "#utils/deep-merge";
-import { breakpoints } from "./breakpoints";
+/**
+ * Installation lifecycle: `configureTerraUI` / `bootstrapTerraUI` and the
+ * read-only getters components use (icons, image renderer, component defaults).
+ *
+ * Theme resolution lives in `resolve-config.ts`; native calls in
+ * `unistyles-adapter.ts`; the selection snapshot and installed config in
+ * `selection-store.ts`. This module orchestrates them in a fixed order:
+ * build and validate (pure, may throw) → native work → publish state.
+ */
 import { defaultIcons } from "./defaults/icons";
 import { defaultImage } from "./defaults/image";
-import { buildRadiusScale, buildSpacingScale, defaultDarkTheme, defaultLightTheme } from "./theme";
+import { warnContrastDiagnostics } from "./diagnostics";
+import { normalizeThemeInput, resolveThemeScheme, resolveThemes } from "./resolve-config";
+import { getInstalledConfig, publishThemeSelection, setInstalledConfig } from "./selection-store";
 import type {
   ComponentDefaults,
   DefaultRadiusToken,
   ElevationKey,
-  NormalizedAccent,
   RadiusComponent,
   Scheme,
   TerraConfig,
@@ -18,8 +23,10 @@ import type {
   TerraImageComponent,
   TerraSemanticIconName,
   TerraTheme,
-  TerraThemeOverride,
+  TerraThemeInput,
+  ThemeMode,
 } from "./types";
+import { applyMode, configureUnistyles, hasConfiguredUnistyles, updateThemes } from "./unistyles-adapter";
 
 // ─── Radius / elevation defaults ─────────────────────────────────────────────
 
@@ -28,7 +35,7 @@ const DEFAULT_RADIUS: DefaultRadiusToken = "md";
 /** Fallback when the surface elevation is not configured. */
 const DEFAULT_ELEVATION: ElevationKey = "none";
 
-type ResolvedRadius = Record<RadiusComponent, DefaultRadiusToken>;
+type ResolvedRadius = Readonly<Record<RadiusComponent, DefaultRadiusToken>>;
 
 /** Resolves each component's default radius from the `components` config. */
 const resolveDefaultRadius = (components?: ComponentDefaults): ResolvedRadius => ({
@@ -44,111 +51,93 @@ declare module "react-native-unistyles" {
   }
 }
 
-interface Registry {
-  baseLight: TerraTheme;
-  baseDark: TerraTheme;
-  accents: Record<string, NormalizedAccent>;
-  currentAccent?: string;
-  defaultRadius: ResolvedRadius;
-  surfaceElevation: ElevationKey;
-  icons: Record<string, TerraIconComponent>;
-  imageComponent: TerraImageComponent;
-  configured: boolean;
+// ─── Private registry state ──────────────────────────────────────────────────
+
+/** Adapters and component defaults, installed at configure time only. */
+interface RegistrySettings {
+  readonly defaultRadius: ResolvedRadius;
+  readonly surfaceElevation: ElevationKey;
+  readonly icons: Readonly<Partial<Record<string, TerraIconComponent>>>;
+  readonly imageComponent: TerraImageComponent;
 }
 
-const registry: Registry = {
-  baseLight: defaultLightTheme,
-  baseDark: defaultDarkTheme,
-  accents: {},
-  currentAccent: undefined,
-  defaultRadius: resolveDefaultRadius(),
-  surfaceElevation: DEFAULT_ELEVATION,
-  icons: {},
-  imageComponent: defaultImage,
-  configured: false,
-};
+const buildSettings = (config: TerraConfig): RegistrySettings => ({
+  defaultRadius: resolveDefaultRadius(config.components),
+  surfaceElevation: config.components?.surface?.elevation ?? DEFAULT_ELEVATION,
+  icons: { ...(config.icons ?? {}) },
+  imageComponent: config.image ?? defaultImage,
+});
+
+let settings: RegistrySettings = buildSettings({});
+
+/**
+ * Installation state. `unconfigured` → nothing has run; `fallback` → the
+ * provider's placeholder defaults are live and an app call still replaces
+ * them; `app` → the app configured, later calls are ignored with a warning.
+ */
+let installation: "unconfigured" | "fallback" | "app" = "unconfigured";
 
-/** @internal */
-export const getRegistry = (): Registry => registry;
+// ─── Getters (read-only) ─────────────────────────────────────────────────────
 
-export const getIsConfigured = (): boolean => registry.configured;
+export const getIsConfigured = (): boolean => installation !== "unconfigured";
 
-export const getAccentNames = (): string[] => Object.keys(registry.accents);
+/** Names of the registered accents, in declaration order. Returns a fresh array. */
+export const getAccentNames = (): string[] => [...getInstalledConfig().accentNames];
 
-export const getImageComponent = (): TerraImageComponent => registry.imageComponent;
+export const getImageComponent = (): TerraImageComponent => settings.imageComponent;
 
 export const getIcon = (name: string): TerraIconComponent | undefined =>
-  registry.icons[name] ?? defaultIcons[name as TerraSemanticIconName];
+  settings.icons[name] ?? defaultIcons[name as TerraSemanticIconName];
 
 export const getRequiredIcon = (name: TerraSemanticIconName): TerraIconComponent =>
-  registry.icons[name] ?? defaultIcons[name];
+  settings.icons[name] ?? defaultIcons[name];
 
 /**
  * The configured default corner radius for a component (Button, Surface).
  * Set via {@link configureTerraUI}; defaults to `'md'`.
  */
 export const getDefaultRadius = (component: RadiusComponent): DefaultRadiusToken =>
-  registry.defaultRadius[component];
+  settings.defaultRadius[component];
 
 /**
  * The configured default drop-shadow depth for Surface (`'none'` = no shadow).
  * Set via {@link configureTerraUI}; defaults to `'none'`.
  */
-export const getSurfaceElevation = (): ElevationKey => registry.surfaceElevation;
+export const getSurfaceElevation = (): ElevationKey => settings.surfaceElevation;
 
-/** Resolves a scheme's theme = base ⊕ the named accent's partial override. */
+/**
+ * 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
+ * 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 {
-  const base = scheme === "light" ? registry.baseLight : registry.baseDark;
-  const accent = accentName ? registry.accents[accentName] : undefined;
-  return deepMerge(base, accent ? accent[scheme] : undefined);
-}
-
-const mergeThemeOverride = (theme: TerraTheme, override?: TerraThemeOverride): TerraTheme => {
-  if (!override) return theme;
-
-  const { radius, spacing, ...rest } = override;
-  let next = deepMerge(theme, rest);
-
-  if (radius) {
-    const { base, ...radiusTokens } = radius;
-    if (base != null) {
-      next = deepMerge(next, { radius: buildRadiusScale(base) });
-    }
-    next = deepMerge(next, { radius: radiusTokens });
-  }
-
-  if (spacing) {
-    const { base, ...spacingTokens } = spacing;
-    if (base != null) {
-      next = deepMerge(next, { spacing: buildSpacingScale(base) });
+  const config = getInstalledConfig();
+  let accent: string | null = null;
+  if (accentName !== undefined) {
+    if (config.accentNames.includes(accentName)) {
+      accent = accentName;
+    } else if (__DEV__) {
+      console.warn(`[react-native-terra-ui] Unknown accent "${accentName}"; resolving the base theme.`);
     }
-    next = deepMerge(next, { spacing: spacingTokens });
   }
+  return resolveThemeScheme(config, scheme, accent).theme;
+}
 
-  return next;
-};
-
-/**
- * Whether the live configuration is the provider's fallback rather than an
- * app's own call. A fallback is a placeholder, so a real call still replaces
- * it; two real calls remain an error.
- */
-let configuredByFallback = false;
-
-/**
- * Whether `StyleSheet.configure` has run. Tracked separately from
- * {@link Registry.configured} because it may only happen once per app.
- */
-let unistylesConfigured = false;
+// ─── Configuration ───────────────────────────────────────────────────────────
 
 /**
  * Configure Terra UI's themes. Call ONCE, as early as possible — before any
  * component renders (e.g. top of the app entry, imported from
  * `react-native-terra-ui/theme`). With no arguments it registers the default
  * theme; `<TerraUIProvider>` calls it for you if you haven't.
+ *
+ * Invalid input throws {@link TerraConfigError} before anything is installed,
+ * so a corrected retry is still the app's one configure call.
  */
 export function configureTerraUI(config: TerraConfig = {}): void {
-  if (registry.configured && !configuredByFallback) {
+  if (installation === "app") {
     if (__DEV__ && Object.keys(config).length > 0) {
       console.warn(
         "[react-native-terra-ui] configureTerraUI() was called more than once; the later call was ignored."
@@ -157,8 +146,7 @@ export function configureTerraUI(config: TerraConfig = {}): void {
     return;
   }
 
-  configuredByFallback = false;
-  applyConfig(config);
+  applyConfig(config, "app");
 }
 
 /**
@@ -174,68 +162,62 @@ export function configureTerraUI(config: TerraConfig = {}): void {
  * @internal
  */
 export function bootstrapTerraUI(): void {
-  if (registry.configured) {
+  if (installation !== "unconfigured") {
     return;
   }
 
-  applyConfig({});
-  configuredByFallback = true;
+  applyConfig({}, "fallback");
 }
 
-function applyConfig(config: TerraConfig): void {
-  registry.configured = true;
-
-  registry.baseLight = mergeThemeOverride(
-    mergeThemeOverride(defaultLightTheme, config.shared),
-    config.schemes?.light
-  );
-  registry.baseDark = mergeThemeOverride(
-    mergeThemeOverride(defaultDarkTheme, config.shared),
-    config.schemes?.dark
-  );
-
-  registry.defaultRadius = resolveDefaultRadius(config.components);
-  registry.surfaceElevation = config.components?.surface?.elevation ?? DEFAULT_ELEVATION;
-  registry.icons = config.icons ?? {};
-  registry.imageComponent = config.image ?? defaultImage;
-
-  registry.accents = {};
-  for (const [name, accent] of Object.entries(config.accents ?? {})) {
-    registry.accents[name] = normalizeAccent(accent);
-  }
-  const { defaultAccent } = config;
-  registry.currentAccent = defaultAccent && registry.accents[defaultAccent] ? defaultAccent : undefined;
-
-  const themes = {
-    light: resolveTheme("light", registry.currentAccent),
-    dark: resolveTheme("dark", registry.currentAccent),
-  };
-
-  const adaptive = config.adaptiveThemes ?? true;
-  const settings = config.initialScheme
-    ? { initialTheme: config.initialScheme }
-    : adaptive
-      ? { adaptiveThemes: true as const }
-      : { initialTheme: "light" as const };
-
-  if (unistylesConfigured) {
-    // `StyleSheet.configure` is a one-time startup call — calling it again
-    // leaves the themes it already registered in place, which would strand an
-    // app's config behind the fallback's defaults. Hand the rebuilt themes to
-    // the runtime instead, the same way `applyAccent` swaps a palette.
-    UnistylesRuntime.updateTheme("light", () => themes.light);
-    UnistylesRuntime.updateTheme("dark", () => themes.dark);
-
-    if ("adaptiveThemes" in settings) {
-      UnistylesRuntime.setAdaptiveThemes(true);
-    } else {
-      UnistylesRuntime.setAdaptiveThemes(false);
-      UnistylesRuntime.setTheme(settings.initialTheme);
+/**
+ * Derives the starting theme mode. `mode` wins; otherwise the deprecated
+ * settings keep their existing meaning: `initialScheme` pins that scheme,
+ * `adaptiveThemes: false` starts in light, and the default follows the system.
+ */
+function deriveMode(config: TerraConfig): ThemeMode {
+  const hasLegacy = config.initialScheme !== undefined || config.adaptiveThemes !== undefined;
+  if (config.mode !== undefined) {
+    if (__DEV__ && hasLegacy) {
+      console.warn(
+        "[react-native-terra-ui] configureTerraUI(): `mode` was supplied together with the deprecated `initialScheme` / `adaptiveThemes`; `mode` wins and the deprecated settings are ignored."
+      );
     }
+    return config.mode;
+  }
+  if (config.initialScheme !== undefined) return config.initialScheme;
+  if (config.adaptiveThemes === false) return "light";
+  return "system";
+}
 
-    return;
+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 mode = deriveMode(config);
+  const { themes, diagnostics } = resolveThemes(themeConfig, themeConfig.defaultAccent);
+  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
+  // app's config is never stranded behind the fallback's defaults.
+  if (hasConfiguredUnistyles()) {
+    updateThemes(themes);
+    applyMode(mode);
+  } else {
+    configureUnistyles({ themes, mode });
   }
 
-  StyleSheet.configure({ themes, settings, breakpoints });
-  unistylesConfigured = true;
+  // (c) Publish only after native work succeeded.
+  installation = kind;
+  settings = nextSettings;
+  setInstalledConfig(themeConfig);
+  publishThemeSelection({ accent: themeConfig.defaultAccent ?? undefined, mode });
+
+  warnContrastDiagnostics(diagnostics);
 }