@tekton-ui/core 0.2.0

package/dist/token-resolver.js

@@ -0,0 +1,122 @@
+/**
+ * @tekton-ui/core - Token Resolution Engine
+ * Resolves token references to final values with fallback chain support
+ * [SPEC-COMPONENT-001-A] [TOKEN-RESOLUTION]
+ */
+// ============================================================================
+// Token Resolution Functions
+// ============================================================================
+/**
+ * Resolves a token reference to its final value
+ *
+ * Supports:
+ * - Dot-notation references: "atomic.color.blue.500"
+ * - Multi-level references: "component.button.primary.background" → "semantic.foreground.accent" → "atomic.color.blue.500"
+ * - Direct values: "#3b82f6" (returned as-is)
+ * - Circular reference detection
+ *
+ * @param ref - Token reference or direct value
+ * @param tokens - Theme token structure
+ * @param visited - Internal tracking for circular reference detection
+ * @returns Resolved token value
+ * @throws Error if token not found or circular reference detected
+ *
+ * @example
+ * ```typescript
+ * resolveToken('atomic.color.blue.500', tokens) // → '#3b82f6'
+ * resolveToken('semantic.background.page', tokens) // → '#f9fafb' (via atomic.color.neutral.50)
+ * resolveToken('#3b82f6', tokens) // → '#3b82f6' (direct value)
+ * ```
+ */
+export function resolveToken(ref, tokens, visited = new Set()) {
+    // Prevent circular references
+    if (visited.has(ref)) {
+        throw new Error(`Circular token reference detected: ${ref}`);
+    }
+    visited.add(ref);
+    // If not a reference (doesn't contain dot or doesn't start with layer name), return as-is
+    if (!ref.includes('.')) {
+        return ref;
+    }
+    // Check if it's a token reference (starts with atomic, semantic, or component)
+    const startsWithLayer = ref.startsWith('atomic.') || ref.startsWith('semantic.') || ref.startsWith('component.');
+    if (!startsWithLayer) {
+        return ref; // Return direct value like "#3b82f6"
+    }
+    // Parse reference path
+    const parts = ref.split('.');
+    const [layer, ...path] = parts;
+    // Navigate token tree
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let value = tokens;
+    for (const part of [layer, ...path]) {
+        value = value?.[part];
+        if (value === undefined) {
+            throw new Error(`Token not found: ${ref}`);
+        }
+    }
+    // If value is another reference, resolve recursively
+    if (typeof value === 'string' &&
+        (value.startsWith('atomic.') || value.startsWith('semantic.') || value.startsWith('component.'))) {
+        return resolveToken(value, tokens, visited);
+    }
+    return value;
+}
+/**
+ * Resolves token with fallback chain: Component → Semantic → Atomic
+ *
+ * Attempts to resolve tokens in order of specificity:
+ * 1. Component-level token (most specific)
+ * 2. Semantic-level token (medium specificity)
+ * 3. Atomic-level token (least specific, guaranteed to exist)
+ *
+ * This enables graceful degradation when component or semantic tokens are missing.
+ *
+ * @param componentRef - Component-level token reference
+ * @param semanticRef - Semantic-level token reference (fallback)
+ * @param atomicRef - Atomic-level token reference (final fallback)
+ * @param tokens - Theme token structure
+ * @returns Resolved token value from first successful resolution
+ * @throws Error if all fallback attempts fail
+ *
+ * @example
+ * ```typescript
+ * // Returns component token if exists
+ * resolveWithFallback(
+ *   'component.button.primary.background',
+ *   'semantic.foreground.accent',
+ *   'atomic.color.blue.500',
+ *   tokens
+ * ) // → '#3b82f6'
+ *
+ * // Falls back to semantic if component missing
+ * resolveWithFallback(
+ *   'component.button.nonexistent.background',
+ *   'semantic.foreground.accent',
+ *   'atomic.color.blue.500',
+ *   tokens
+ * ) // → '#3b82f6' (via semantic)
+ * ```
+ */
+export function resolveWithFallback(componentRef, semanticRef, atomicRef, tokens) {
+    // Try component token first
+    try {
+        return resolveToken(componentRef, tokens);
+    }
+    catch {
+        // Fallback to semantic token
+        try {
+            return resolveToken(semanticRef, tokens);
+        }
+        catch {
+            // Final fallback to atomic token
+            try {
+                return resolveToken(atomicRef, tokens);
+            }
+            catch {
+                throw new Error(`Failed to resolve token with fallback: ${componentRef} → ${semanticRef} → ${atomicRef}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=token-resolver.js.map

package/dist/token-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-resolver.js","sourceRoot":"","sources":["../src/token-resolver.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAWH,+EAA+E;AAC/E,6BAA6B;AAC7B,+EAA+E;AAE/E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,YAAY,CAC1B,GAAmB,EACnB,MAAiC,EACjC,UAAuB,IAAI,GAAG,EAAE;IAEhC,8BAA8B;IAC9B,IAAI,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CAAC,sCAAsC,GAAG,EAAE,CAAC,CAAC;IAC/D,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAEjB,0FAA0F;IAC1F,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACvB,OAAO,GAAG,CAAC;IACb,CAAC;IAED,+EAA+E;IAC/E,MAAM,eAAe,GACnB,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,GAAG,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,GAAG,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;IAC3F,IAAI,CAAC,eAAe,EAAE,CAAC;QACrB,OAAO,GAAG,CAAC,CAAC,qCAAqC;IACnD,CAAC;IAED,uBAAuB;IACvB,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC7B,MAAM,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,GAAG,KAAK,CAAC;IAE/B,sBAAsB;IACtB,8DAA8D;IAC9D,IAAI,KAAK,GAAQ,MAAM,CAAC;IACxB,KAAK,MAAM,IAAI,IAAI,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;QACpC,KAAK,GAAG,KAAK,EAAE,CAAC,IAAI,CAAC,CAAC;QACtB,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CAAC,oBAAoB,GAAG,EAAE,CAAC,CAAC;QAC7C,CAAC;IACH,CAAC;IAED,qDAAqD;IACrD,IACE,OAAO,KAAK,KAAK,QAAQ;QACzB,CAAC,KAAK,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,KAAK,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,EAChG,CAAC;QACD,OAAO,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9C,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,UAAU,mBAAmB,CACjC,YAAoB,EACpB,WAAmB,EACnB,SAAiB,EACjB,MAAiC;IAEjC,4BAA4B;IAC5B,IAAI,CAAC;QACH,OAAO,YAAY,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAC5C,CAAC;IAAC,MAAM,CAAC;QACP,6BAA6B;QAC7B,IAAI,CAAC;YACH,OAAO,YAAY,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;QAC3C,CAAC;QAAC,MAAM,CAAC;YACP,iCAAiC;YACjC,IAAI,CAAC;gBACH,OAAO,YAAY,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;YACzC,CAAC;YAAC,MAAM,CAAC;gBACP,MAAM,IAAI,KAAK,CACb,0CAA0C,YAAY,MAAM,WAAW,MAAM,SAAS,EAAE,CACzF,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/token-validation.d.ts

@@ -0,0 +1,432 @@
+/**
+ * @tekton-ui/core - Token Validation
+ * Runtime validation using Zod schemas for 3-layer token architecture
+ * [SPEC-COMPONENT-001-A] [TOKEN-VALIDATION]
+ */
+import { z } from 'zod';
+/**
+ * Theme with Tokens Schema
+ * Validates complete 3-layer token structure with optional dark mode
+ */
+export declare const ThemeWithTokensSchema: z.ZodObject<{
+    /** 3-layer token structure */
+    tokens: z.ZodObject<{
+        atomic: z.ZodObject<{
+            /** Color palettes with shades */
+            color: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>;
+            /** Spacing scale */
+            spacing: z.ZodRecord<z.ZodString, z.ZodString>;
+            /** Border radius values */
+            radius: z.ZodRecord<z.ZodString, z.ZodString>;
+            /** Typography definitions */
+            typography: z.ZodRecord<z.ZodString, z.ZodObject<{
+                fontSize: z.ZodString;
+                lineHeight: z.ZodString;
+                fontWeight: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                fontSize: string;
+                fontWeight: string;
+                lineHeight: string;
+            }, {
+                fontSize: string;
+                fontWeight: string;
+                lineHeight: string;
+            }>>;
+            /** Shadow definitions */
+            shadow: z.ZodRecord<z.ZodString, z.ZodString>;
+            /** Transition definitions (optional) */
+            transition: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            spacing: Record<string, string>;
+            color: Record<string, Record<string, string>>;
+            shadow: Record<string, string>;
+            typography: Record<string, {
+                fontSize: string;
+                fontWeight: string;
+                lineHeight: string;
+            }>;
+            radius: Record<string, string>;
+            transition?: Record<string, string> | undefined;
+        }, {
+            spacing: Record<string, string>;
+            color: Record<string, Record<string, string>>;
+            shadow: Record<string, string>;
+            typography: Record<string, {
+                fontSize: string;
+                fontWeight: string;
+                lineHeight: string;
+            }>;
+            radius: Record<string, string>;
+            transition?: Record<string, string> | undefined;
+        }>;
+        semantic: z.ZodObject<{
+            /** Background colors with semantic meaning */
+            background: z.ZodObject<{
+                page: z.ZodString;
+                surface: z.ZodString;
+                elevated: z.ZodString;
+                muted: z.ZodString;
+                inverse: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                page: string;
+                muted: string;
+                inverse: string;
+                elevated: string;
+                surface: string;
+            }, {
+                page: string;
+                muted: string;
+                inverse: string;
+                elevated: string;
+                surface: string;
+            }>;
+            /** Foreground (text) colors with semantic meaning */
+            foreground: z.ZodObject<{
+                primary: z.ZodString;
+                secondary: z.ZodString;
+                muted: z.ZodString;
+                inverse: z.ZodString;
+                accent: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                primary: string;
+                secondary: string;
+                muted: string;
+                accent: string;
+                inverse: string;
+            }, {
+                primary: string;
+                secondary: string;
+                muted: string;
+                accent: string;
+                inverse: string;
+            }>;
+            /** Border colors with semantic meaning */
+            border: z.ZodObject<{
+                default: z.ZodString;
+                muted: z.ZodString;
+                focus: z.ZodString;
+                error: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                focus: string;
+                default: string;
+                error: string;
+                muted: string;
+            }, {
+                focus: string;
+                default: string;
+                error: string;
+                muted: string;
+            }>;
+            /** Surface colors with semantic meaning */
+            surface: z.ZodObject<{
+                primary: z.ZodString;
+                secondary: z.ZodString;
+                tertiary: z.ZodString;
+                inverse: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                primary: string;
+                secondary: string;
+                inverse: string;
+                tertiary: string;
+            }, {
+                primary: string;
+                secondary: string;
+                inverse: string;
+                tertiary: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            background: {
+                page: string;
+                muted: string;
+                inverse: string;
+                elevated: string;
+                surface: string;
+            };
+            foreground: {
+                primary: string;
+                secondary: string;
+                muted: string;
+                accent: string;
+                inverse: string;
+            };
+            border: {
+                focus: string;
+                default: string;
+                error: string;
+                muted: string;
+            };
+            surface: {
+                primary: string;
+                secondary: string;
+                inverse: string;
+                tertiary: string;
+            };
+        }, {
+            background: {
+                page: string;
+                muted: string;
+                inverse: string;
+                elevated: string;
+                surface: string;
+            };
+            foreground: {
+                primary: string;
+                secondary: string;
+                muted: string;
+                accent: string;
+                inverse: string;
+            };
+            border: {
+                focus: string;
+                default: string;
+                error: string;
+                muted: string;
+            };
+            surface: {
+                primary: string;
+                secondary: string;
+                inverse: string;
+                tertiary: string;
+            };
+        }>;
+        component: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        component: Record<string, any>;
+        semantic: {
+            background: {
+                page: string;
+                muted: string;
+                inverse: string;
+                elevated: string;
+                surface: string;
+            };
+            foreground: {
+                primary: string;
+                secondary: string;
+                muted: string;
+                accent: string;
+                inverse: string;
+            };
+            border: {
+                focus: string;
+                default: string;
+                error: string;
+                muted: string;
+            };
+            surface: {
+                primary: string;
+                secondary: string;
+                inverse: string;
+                tertiary: string;
+            };
+        };
+        atomic: {
+            spacing: Record<string, string>;
+            color: Record<string, Record<string, string>>;
+            shadow: Record<string, string>;
+            typography: Record<string, {
+                fontSize: string;
+                fontWeight: string;
+                lineHeight: string;
+            }>;
+            radius: Record<string, string>;
+            transition?: Record<string, string> | undefined;
+        };
+    }, {
+        component: Record<string, any>;
+        semantic: {
+            background: {
+                page: string;
+                muted: string;
+                inverse: string;
+                elevated: string;
+                surface: string;
+            };
+            foreground: {
+                primary: string;
+                secondary: string;
+                muted: string;
+                accent: string;
+                inverse: string;
+            };
+            border: {
+                focus: string;
+                default: string;
+                error: string;
+                muted: string;
+            };
+            surface: {
+                primary: string;
+                secondary: string;
+                inverse: string;
+                tertiary: string;
+            };
+        };
+        atomic: {
+            spacing: Record<string, string>;
+            color: Record<string, Record<string, string>>;
+            shadow: Record<string, string>;
+            typography: Record<string, {
+                fontSize: string;
+                fontWeight: string;
+                lineHeight: string;
+            }>;
+            radius: Record<string, string>;
+            transition?: Record<string, string> | undefined;
+        };
+    }>;
+    /** Optional dark mode token overrides */
+    darkMode: z.ZodOptional<z.ZodObject<{
+        tokens: z.ZodObject<{
+            semantic: z.ZodRecord<z.ZodString, z.ZodAny>;
+            component: z.ZodRecord<z.ZodString, z.ZodAny>;
+        }, "strip", z.ZodTypeAny, {
+            component: Record<string, any>;
+            semantic: Record<string, any>;
+        }, {
+            component: Record<string, any>;
+            semantic: Record<string, any>;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        tokens: {
+            component: Record<string, any>;
+            semantic: Record<string, any>;
+        };
+    }, {
+        tokens: {
+            component: Record<string, any>;
+            semantic: Record<string, any>;
+        };
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    tokens: {
+        component: Record<string, any>;
+        semantic: {
+            background: {
+                page: string;
+                muted: string;
+                inverse: string;
+                elevated: string;
+                surface: string;
+            };
+            foreground: {
+                primary: string;
+                secondary: string;
+                muted: string;
+                accent: string;
+                inverse: string;
+            };
+            border: {
+                focus: string;
+                default: string;
+                error: string;
+                muted: string;
+            };
+            surface: {
+                primary: string;
+                secondary: string;
+                inverse: string;
+                tertiary: string;
+            };
+        };
+        atomic: {
+            spacing: Record<string, string>;
+            color: Record<string, Record<string, string>>;
+            shadow: Record<string, string>;
+            typography: Record<string, {
+                fontSize: string;
+                fontWeight: string;
+                lineHeight: string;
+            }>;
+            radius: Record<string, string>;
+            transition?: Record<string, string> | undefined;
+        };
+    };
+    darkMode?: {
+        tokens: {
+            component: Record<string, any>;
+            semantic: Record<string, any>;
+        };
+    } | undefined;
+}, {
+    tokens: {
+        component: Record<string, any>;
+        semantic: {
+            background: {
+                page: string;
+                muted: string;
+                inverse: string;
+                elevated: string;
+                surface: string;
+            };
+            foreground: {
+                primary: string;
+                secondary: string;
+                muted: string;
+                accent: string;
+                inverse: string;
+            };
+            border: {
+                focus: string;
+                default: string;
+                error: string;
+                muted: string;
+            };
+            surface: {
+                primary: string;
+                secondary: string;
+                inverse: string;
+                tertiary: string;
+            };
+        };
+        atomic: {
+            spacing: Record<string, string>;
+            color: Record<string, Record<string, string>>;
+            shadow: Record<string, string>;
+            typography: Record<string, {
+                fontSize: string;
+                fontWeight: string;
+                lineHeight: string;
+            }>;
+            radius: Record<string, string>;
+            transition?: Record<string, string> | undefined;
+        };
+    };
+    darkMode?: {
+        tokens: {
+            component: Record<string, any>;
+            semantic: Record<string, any>;
+        };
+    } | undefined;
+}>;
+/**
+ * Validation result with detailed error information
+ */
+export interface ValidationResult {
+    /** Whether validation passed */
+    valid: boolean;
+    /** Error messages if validation failed (undefined if valid) */
+    errors?: string[];
+}
+/**
+ * Validates a theme with token structure
+ *
+ * Uses Zod schema validation to ensure:
+ * - All required atomic tokens are present
+ * - All required semantic tokens are defined
+ * - Component tokens structure is valid
+ * - Dark mode tokens (if present) follow correct structure
+ *
+ * @param theme - Theme object to validate
+ * @returns Validation result with success status and error messages
+ *
+ * @example
+ * ```typescript
+ * const result = validateTheme(myTheme);
+ * if (!result.valid) {
+ *   console.error('Validation errors:', result.errors);
+ * }
+ * ```
+ */
+export declare function validateTheme(theme: unknown): ValidationResult;
+//# sourceMappingURL=token-validation.d.ts.map

package/dist/token-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-validation.d.ts","sourceRoot":"","sources":["../src/token-validation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiGxB;;;GAGG;AACH,eAAO,MAAM,qBAAqB;IAChC,8BAA8B;;;YA3F9B,iCAAiC;;YAGjC,oBAAoB;;YAGpB,2BAA2B;;YAG3B,6BAA6B;;;;;;;;;;;;;;YAS7B,yBAAyB;;YAGzB,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;YASxC,8CAA8C;;;;;;;;;;;;;;;;;;;;YAS9C,qDAAqD;;;;;;;;;;;;;;;;;;;;YASrD,0CAA0C;;;;;;;;;;;;;;;;;YAQ1C,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0C3C,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASzC,CAAC;AAMH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,gCAAgC;IAChC,KAAK,EAAE,OAAO,CAAC;IAEf,+DAA+D;IAC/D,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAc9D"}

package/dist/token-validation.js

@@ -0,0 +1,140 @@
+/**
+ * @tekton-ui/core - Token Validation
+ * Runtime validation using Zod schemas for 3-layer token architecture
+ * [SPEC-COMPONENT-001-A] [TOKEN-VALIDATION]
+ */
+import { z } from 'zod';
+// ============================================================================
+// Zod Schema Definitions
+// ============================================================================
+/**
+ * Atomic Tokens Schema - Layer 1
+ * Validates raw design values (colors, spacing, typography, etc.)
+ */
+const AtomicTokensSchema = z.object({
+    /** Color palettes with shades */
+    color: z.record(z.record(z.string())),
+    /** Spacing scale */
+    spacing: z.record(z.string()),
+    /** Border radius values */
+    radius: z.record(z.string()),
+    /** Typography definitions */
+    typography: z.record(z.object({
+        fontSize: z.string(),
+        lineHeight: z.string(),
+        fontWeight: z.string(),
+    })),
+    /** Shadow definitions */
+    shadow: z.record(z.string()),
+    /** Transition definitions (optional) */
+    transition: z.record(z.string()).optional(),
+});
+/**
+ * Semantic Tokens Schema - Layer 2
+ * Validates meaning-based token mappings
+ */
+const SemanticTokensSchema = z.object({
+    /** Background colors with semantic meaning */
+    background: z.object({
+        page: z.string(),
+        surface: z.string(),
+        elevated: z.string(),
+        muted: z.string(),
+        inverse: z.string(),
+    }),
+    /** Foreground (text) colors with semantic meaning */
+    foreground: z.object({
+        primary: z.string(),
+        secondary: z.string(),
+        muted: z.string(),
+        inverse: z.string(),
+        accent: z.string(),
+    }),
+    /** Border colors with semantic meaning */
+    border: z.object({
+        default: z.string(),
+        muted: z.string(),
+        focus: z.string(),
+        error: z.string(),
+    }),
+    /** Surface colors with semantic meaning */
+    surface: z.object({
+        primary: z.string(),
+        secondary: z.string(),
+        tertiary: z.string(),
+        inverse: z.string(),
+    }),
+});
+/**
+ * Component Tokens Schema - Layer 3
+ * Validates component-specific token bindings
+ * Flexible to allow extensible component definitions
+ */
+const ComponentTokensSchema = z.record(z.any());
+/**
+ * Dark Mode Semantic Tokens Schema
+ * Allows partial overrides of semantic tokens for dark mode
+ * Uses flexible validation since dark mode is opt-in and can override any semantic token
+ */
+const DarkModeSemanticTokensSchema = z.record(z.any());
+/**
+ * Dark Mode Component Tokens Schema
+ * Allows partial overrides of component tokens for dark mode
+ * Uses flexible validation for extensibility
+ */
+const DarkModeComponentTokensSchema = z.record(z.any());
+/**
+ * Theme with Tokens Schema
+ * Validates complete 3-layer token structure with optional dark mode
+ */
+export const ThemeWithTokensSchema = z.object({
+    /** 3-layer token structure */
+    tokens: z.object({
+        atomic: AtomicTokensSchema,
+        semantic: SemanticTokensSchema,
+        component: ComponentTokensSchema,
+    }),
+    /** Optional dark mode token overrides */
+    darkMode: z
+        .object({
+        tokens: z.object({
+            semantic: DarkModeSemanticTokensSchema,
+            component: DarkModeComponentTokensSchema,
+        }),
+    })
+        .optional(),
+});
+/**
+ * Validates a theme with token structure
+ *
+ * Uses Zod schema validation to ensure:
+ * - All required atomic tokens are present
+ * - All required semantic tokens are defined
+ * - Component tokens structure is valid
+ * - Dark mode tokens (if present) follow correct structure
+ *
+ * @param theme - Theme object to validate
+ * @returns Validation result with success status and error messages
+ *
+ * @example
+ * ```typescript
+ * const result = validateTheme(myTheme);
+ * if (!result.valid) {
+ *   console.error('Validation errors:', result.errors);
+ * }
+ * ```
+ */
+export function validateTheme(theme) {
+    const result = ThemeWithTokensSchema.safeParse(theme);
+    if (!result.success) {
+        return {
+            valid: false,
+            errors: result.error.errors.map(e => {
+                const path = e.path.join('.');
+                return `${path}: ${e.message}`;
+            }),
+        };
+    }
+    return { valid: true };
+}
+//# sourceMappingURL=token-validation.js.map