@nikkory/vibe-engine 4.0.0

package/dist/ui-studio/resolution/FactorResolver.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Factor Resolver
+ * 3-Layer resolution engine: Tier → Component → Design System
+ *
+ * @packageDocumentation
+ * @module generators/FactorResolver
+ * @since 4.0.0
+ *
+ * Powered by Nikkory
+ */
+import type { DesignSystem, ComponentType } from '../types';
+import type { FactorId, FactorValue, ResolvedFactors, FactorResolverInput } from '../../types/algorithm-engine.types';
+/**
+ * Factor Resolver
+ *
+ * Resolves factors through a 3-layer system:
+ * - Layer 1: Tier defines factor RANGE (1-6, 1-14, 1-24)
+ * - Layer 2: Component defines factor APPLICABILITY (null = skip)
+ * - Layer 3: Design System defines factor VALUES (Tailwind classes)
+ *
+ * @example
+ * ```typescript
+ * const resolver = new FactorResolver();
+ * const resolved = resolver.resolve({
+ *   componentType: 'button',
+ *   designSystem: 'material-design',
+ *   tier: 'enterprise',
+ *   factorOverrides: { 2: 'lg' }, // Override size to large
+ * });
+ *
+ * // resolved.appliedFactors contains Map of FactorId -> FactorValue
+ * // resolved.skippedFactors contains FactorIds that don't apply to button
+ * // resolved.overriddenFactors contains FactorIds that were overridden
+ * ```
+ */
+export declare class FactorResolver {
+    /**
+     * Resolve factors through 3-layer system
+     *
+     * @param input - Resolution input with component, design system, tier, and overrides
+     * @returns Resolved factors with applied, skipped, and overridden lists
+     *
+     * @remarks
+     * Resolution flow:
+     * 1. Get factors enabled for the tier (1-6, 1-14, or 1-24)
+     * 2. Filter by component applicability (null factors are skipped)
+     * 3. Get values from design system registry
+     * 4. Apply any user overrides
+     */
+    resolve(input: FactorResolverInput): ResolvedFactors;
+    /**
+     * Resolve a single factor for a design system
+     *
+     * @param designSystem - Design system to get value from
+     * @param factorId - Factor ID to resolve
+     * @returns Factor value or undefined
+     */
+    resolveSingleFactor(designSystem: DesignSystem, factorId: FactorId): FactorValue | undefined;
+    /**
+     * Check if a factor is applicable for a component
+     *
+     * @param componentType - Component type to check
+     * @param factorId - Factor ID to check
+     * @returns True if factor is applicable
+     */
+    isFactorApplicableForComponent(componentType: ComponentType, factorId: FactorId): boolean;
+    /**
+     * Get the applicability type for a factor on a component
+     *
+     * @param componentType - Component type to check
+     * @param factorId - Factor ID to check
+     * @returns 'not-applicable', 'default', or 'override'
+     */
+    getApplicabilityType(componentType: ComponentType, factorId: FactorId): 'not-applicable' | 'default' | 'override';
+    /**
+     * Get all factors that will be applied for a given configuration
+     *
+     * @param input - Resolution input
+     * @returns Array of factor IDs that will be applied
+     */
+    getApplicableFactorIds(input: Omit<FactorResolverInput, 'factorOverrides'>): FactorId[];
+    /**
+     * Validate that all overrides are valid
+     *
+     * @param factorOverrides - Overrides to validate
+     * @returns Object with valid flag and any error messages
+     */
+    validateOverrides(factorOverrides: Partial<Record<FactorId, string>>): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Create a summary of resolved factors
+     *
+     * @param resolved - Resolved factors from resolve()
+     * @returns Summary object with counts and lists
+     */
+    createResolutionSummary(resolved: ResolvedFactors): {
+        totalFactors: number;
+        appliedCount: number;
+        skippedCount: number;
+        overriddenCount: number;
+        appliedFactorNames: string[];
+        skippedFactorNames: string[];
+    };
+    /**
+     * Generate combined Tailwind classes from resolved factors
+     *
+     * @param resolved - Resolved factors from resolve()
+     * @returns Combined Tailwind class string
+     */
+    generateTailwindClasses(resolved: ResolvedFactors): string;
+    /**
+     * Generate combined CSS variables from resolved factors
+     *
+     * @param resolved - Resolved factors from resolve()
+     * @returns Combined CSS variables object
+     */
+    generateCssVariables(resolved: ResolvedFactors): Record<string, string>;
+    /**
+     * Create a FactorValue from an override value string
+     *
+     * @param factorId - Factor ID
+     * @param value - Override value
+     * @returns FactorValue with mapped Tailwind classes
+     */
+    private createOverrideValue;
+    /**
+     * Map a factor value to Tailwind classes
+     *
+     * @param factorId - Factor ID
+     * @param value - Value to map
+     * @returns Tailwind class string
+     */
+    private mapValueToTailwind;
+    /**
+     * Generate CSS variables for an override value
+     *
+     * @param factorId - Factor ID
+     * @param value - Override value
+     * @returns CSS variables object
+     */
+    private generateCssVariablesForOverride;
+}
+/**
+ * Create a new FactorResolver instance
+ *
+ * @returns New FactorResolver instance
+ *
+ * @example
+ * ```typescript
+ * const resolver = createFactorResolver();
+ * const resolved = resolver.resolve({
+ *   componentType: 'button',
+ *   designSystem: 'material-design',
+ *   tier: 'enterprise',
+ * });
+ * ```
+ */
+export declare function createFactorResolver(): FactorResolver;
+/**
+ * Resolve factors with a single function call (convenience wrapper)
+ *
+ * @param input - Resolution input
+ * @returns Resolved factors
+ *
+ * @example
+ * ```typescript
+ * const resolved = resolveFactors({
+ *   componentType: 'card',
+ *   designSystem: 'glassmorphism',
+ *   tier: 'standard',
+ * });
+ * ```
+ */
+export declare function resolveFactors(input: FactorResolverInput): ResolvedFactors;
+/**
+ * Get Tailwind classes for a component configuration
+ *
+ * @param input - Resolution input
+ * @returns Tailwind class string
+ *
+ * @example
+ * ```typescript
+ * const classes = getTailwindClassesForComponent({
+ *   componentType: 'button',
+ *   designSystem: 'brutalism',
+ *   tier: 'enterprise',
+ * });
+ * // Returns combined Tailwind classes for all applied factors
+ * ```
+ */
+export declare function getTailwindClassesForComponent(input: FactorResolverInput): string;
+/**
+ * Get CSS variables for a component configuration
+ *
+ * @param input - Resolution input
+ * @returns CSS variables object
+ */
+export declare function getCssVariablesForComponent(input: FactorResolverInput): Record<string, string>;
+//# sourceMappingURL=FactorResolver.d.ts.map

package/dist/ui-studio/templates/TestGenerator.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Test Generator
+ * Generates Vitest test files for components
+ *
+ * @packageDocumentation
+ * @module ui-studio/templates/TestGenerator
+ * @since 4.0.0
+ *
+ * Powered by Nikkory
+ */
+import type { ResolvedComponentConfig } from '../matrix/types';
+/**
+ * TestGenerator
+ *
+ * Generates Vitest test files for components
+ * LOC breakdown by tier:
+ * - Basic: ~40 LOC (basic rendering tests)
+ * - Standard: ~70 LOC (+ variant/size tests)
+ * - Enterprise: ~100-150 LOC (+ analytics, accessibility, state tests)
+ */
+export declare class TestGenerator {
+    /**
+     * Generate test file from resolved component configuration
+     *
+     * @param resolved - Resolved component configuration from Matrix
+     * @returns Vitest test code
+     */
+    generateFromResolvedConfig(resolved: ResolvedComponentConfig): string;
+    /**
+     * Generate Basic tier tests
+     * - Rendering test
+     * - Children test
+     * - ClassName test
+     */
+    private generateBasicTests;
+    /**
+     * Generate Standard tier tests
+     * - All Basic tests
+     * - Variant tests
+     * - Size tests
+     * - Ref forwarding test
+     */
+    private generateStandardTests;
+    /**
+     * Generate Enterprise tier tests
+     * - All Standard tests
+     * - Analytics tests
+     * - Event handler tests
+     * - Accessibility tests
+     * - Loading state tests
+     * - Memoization tests
+     */
+    private generateEnterpriseTests;
+}
+//# sourceMappingURL=TestGenerator.d.ts.map

package/dist/ui-studio/templates/TierGenerator.d.ts

@@ -0,0 +1,153 @@
+/**
+ * TierGenerator - Generates React components with A+a+b incremental pattern
+ * @packageDocumentation
+ * @module generators/TierGenerator
+ * @since 4.0.0
+ *
+ * Pattern:
+ * - Basic (A): Core functionality (30-50 LOC)
+ * - Standard (A+a): + forwardRef, displayName, variants (50-150 LOC)
+ * - Enterprise (A+a+b): + memo, useCallback, analytics, ARIA (150-300 LOC)
+ *
+ * Powered by Nikkory
+ */
+import type { TierGenerationConfig, GenerationResult, BatchGenerationConfig, BatchGenerationResult } from '../types';
+/**
+ * TierGenerator - Main component generation engine
+ *
+ * @example
+ * ```typescript
+ * const generator = new TierGenerator();
+ * const result = await generator.generate({
+ *   definition: BUTTON_DEFINITION,
+ *   designSystem: 'material-design',
+ *   tier: 'enterprise',
+ *   outputDir: './src/components',
+ * });
+ * ```
+ */
+export declare class TierGenerator {
+    /**
+     * Generate a single component
+     *
+     * @param config - Generation configuration
+     * @returns Generation result with file paths and metadata
+     */
+    generate(config: TierGenerationConfig): GenerationResult;
+    /**
+     * Generate multiple components in batch
+     *
+     * @param config - Batch generation configuration
+     * @returns Batch generation result with statistics
+     */
+    generateBatch(config: BatchGenerationConfig): BatchGenerationResult;
+    /**
+     * Build template data from registry definition
+     */
+    private buildTemplateData;
+    /**
+     * Generate component code from ResolvedComponentConfig (for ComponentGenerator)
+     *
+     * @param config - Resolved component configuration from MatrixResolver
+     * @returns Generated TypeScript component code
+     *
+     * @example
+     * ```typescript
+     * const generator = new TierGenerator();
+     * const code = generator.generateFromResolvedConfig({
+     *   componentName: 'MaterialButtonEnterprise',
+     *   elementType: 'button',
+     *   tier: 'enterprise',
+     *   designSystem: 'material-design',
+     *   classNames: ['rounded-lg', 'shadow-md'],
+     *   imports: ["import { memo, forwardRef } from 'react';"],
+     *   wrappers: ['memo', 'forwardRef'],
+     *   features: ['displayName', 'analytics']
+     * });
+     * ```
+     */
+    generateFromResolvedConfig(config: {
+        readonly componentName: string;
+        readonly elementType: string;
+        readonly tier: string;
+        readonly designSystem: string;
+        readonly classNames: readonly string[];
+        readonly imports: readonly string[];
+        readonly wrappers: readonly string[];
+        readonly features: readonly string[];
+    }): string;
+    /**
+     * Generate component code based on tier (A, A+a, A+a+b pattern)
+     */
+    private generateComponentCode;
+    /**
+     * Generate Basic tier component (A pattern)
+     * - Core functionality only
+     * - React.FC with basic props
+     * - 30-50 LOC
+     */
+    private generateBasicTier;
+    /**
+     * Generate Standard tier component (A+a pattern)
+     * - Basic functionality + enhancements
+     * - forwardRef, displayName, variants
+     * - 50-150 LOC
+     */
+    private generateStandardTier;
+    /**
+     * Generate Enterprise tier component (A+a+b pattern)
+     * - Standard functionality + advanced features
+     * - memo, useCallback, analytics, ARIA
+     * - 150-300 LOC
+     */
+    private generateEnterpriseTier;
+    /**
+     * Generate TypeScript types file
+     */
+    private generateTypesFile;
+    /**
+     * Generate test file
+     */
+    private generateTestFile;
+    /**
+     * Generate Storybook story file
+     */
+    private generateStoryFile;
+    /**
+     * Get component name from definition ID, design system, and tier
+     */
+    private getComponentName;
+    /**
+     * Get component file name
+     */
+    private getComponentFileName;
+    /**
+     * Get HTML element type from definition
+     */
+    private getElementType;
+    /**
+     * Get base CSS classes
+     */
+    private getBaseClasses;
+    /**
+     * Get variant definitions
+     */
+    private getVariants;
+    /**
+     * Get default prop values
+     */
+    private getDefaults;
+    /**
+     * Get imports based on features
+     */
+    private getImports;
+    /**
+     * Get ARIA attributes
+     */
+    private getAriaAttributes;
+    /**
+     * Capitalize first letter of string
+     */
+    private capitalizeFirst;
+}
+//# sourceMappingURL=TierGenerator.d.ts.map

package/dist/ui-studio/templates/TypesGenerator.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Types Generator
+ * Generates TypeScript type definitions for components
+ *
+ * @packageDocumentation
+ * @module ui-studio/templates/TypesGenerator
+ * @since 4.0.0
+ *
+ * Powered by Nikkory
+ */
+import type { ResolvedComponentConfig } from '../matrix/types';
+/**
+ * TypesGenerator
+ *
+ * Generates TypeScript type definition files for components
+ * LOC breakdown by tier:
+ * - Basic: ~20 LOC (basic interface only)
+ * - Standard: ~35 LOC (+ variant/size types)
+ * - Enterprise: ~50-80 LOC (+ event types, analytics types, state types)
+ */
+export declare class TypesGenerator {
+    /**
+     * Generate types file from resolved component configuration
+     *
+     * @param resolved - Resolved component configuration from Matrix
+     * @returns TypeScript type definitions code
+     */
+    generateFromResolvedConfig(resolved: ResolvedComponentConfig): string;
+    /**
+     * Generate Basic tier types
+     * - Basic props interface
+     * - Children and className only
+     */
+    private generateBasicTypes;
+    /**
+     * Generate Standard tier types
+     * - Props interface with variants
+     * - Variant and size type unions
+     */
+    private generateStandardTypes;
+    /**
+     * Generate Enterprise tier types
+     * - Comprehensive props interface
+     * - Event handler types
+     * - Analytics types
+     * - State types
+     * - Accessibility types
+     */
+    private generateEnterpriseTypes;
+}
+//# sourceMappingURL=TypesGenerator.d.ts.map