@tachui/core 0.7.0-alpha1

package/src/validation/plugin-registration.ts

@@ -0,0 +1,249 @@
+/**
+ * Plugin Validation Registration System
+ *
+ * Allows packages to register their own component validators with Core,
+ * maintaining proper architectural separation and plugin independence.
+ */
+
+import type { ComponentValidator } from './comprehensive'
+
+/**
+ * Plugin validation registry
+ */
+const pluginValidators = new Map<string, ComponentValidator>()
+const packageValidators = new Map<string, Set<string>>()
+
+/**
+ * Plugin validation interface for external packages
+ */
+export interface PluginValidationConfig {
+  packageName: string
+  components: ComponentValidationDefinition[]
+}
+
+/**
+ * Component validation definition for registration
+ */
+export interface ComponentValidationDefinition {
+  name: string
+  requiredProps?: string[]
+  optionalProps?: string[]
+  validate?: (args: unknown[]) => void
+  documentation?: string
+}
+
+/**
+ * Register component validator from a plugin package
+ */
+export function registerComponentValidator(validator: ComponentValidator): void {
+  const key = `${validator.packageName}:${validator.componentName}`
+  pluginValidators.set(key, validator)
+
+  // Track validators by package
+  if (!packageValidators.has(validator.packageName)) {
+    packageValidators.set(validator.packageName, new Set())
+  }
+  packageValidators.get(validator.packageName)!.add(validator.componentName)
+
+  // if (process.env.NODE_ENV !== 'production') {
+  //   console.info(`🔍 Registered validator: ${key}`)
+  // }
+}
+
+/**
+ * Unregister component validator
+ */
+export function unregisterComponentValidator(packageName: string, componentName: string): void {
+  const key = `${packageName}:${componentName}`
+  pluginValidators.delete(key)
+
+  const packageSet = packageValidators.get(packageName)
+  if (packageSet) {
+    packageSet.delete(componentName)
+    if (packageSet.size === 0) {
+      packageValidators.delete(packageName)
+    }
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    console.info(`🔍 Unregistered validator: ${key}`)
+  }
+}
+
+/**
+ * Get component validator for validation
+ */
+export function getComponentValidator(packageName: string, componentName: string): ComponentValidator | undefined {
+  const key = `${packageName}:${componentName}`
+  return pluginValidators.get(key)
+}
+
+/**
+ * Register multiple validators from a plugin package
+ */
+export function registerPluginValidation(config: PluginValidationConfig): void {
+  const { packageName, components } = config
+
+  for (const component of components) {
+    const validator: ComponentValidator = {
+      packageName,
+      componentName: component.name,
+      validate: component.validate || createDefaultValidator(packageName, component)
+    }
+
+    registerComponentValidator(validator)
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    console.info(`🔍 Registered ${components.length} validators for package: ${packageName}`)
+  }
+}
+
+/**
+ * Create default validator based on component definition
+ */
+function createDefaultValidator(packageName: string, component: ComponentValidationDefinition) {
+  return (args: unknown[]) => {
+    // Import TachUIValidationError dynamically to avoid circular dependency
+    const { TachUIValidationError } = require('./comprehensive')
+
+    if (component.requiredProps?.length && args.length === 0) {
+      throw new TachUIValidationError(`${component.name} component requires props`, {
+        component: component.name,
+        package: packageName,
+        suggestion: `Add required props: ${component.requiredProps.join(', ')}`,
+        documentation: component.documentation
+      })
+    }
+
+    if (args.length > 0) {
+      const [props] = args
+      if (!props || typeof props !== 'object') {
+        throw new TachUIValidationError(`${component.name} requires a props object`, {
+          component: component.name,
+          package: packageName,
+          suggestion: 'Pass a props object',
+          documentation: component.documentation
+        })
+      }
+
+      // Check required props
+      if (component.requiredProps) {
+        const propsObj = props as any
+        for (const requiredProp of component.requiredProps) {
+          if (propsObj[requiredProp] === undefined) {
+            throw new TachUIValidationError(`${component.name} ${requiredProp} property is required`, {
+              component: component.name,
+              package: packageName,
+              suggestion: `Provide a value for ${requiredProp}`,
+              documentation: component.documentation
+            })
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Get validation statistics
+ */
+export function getValidationStats(): {
+  totalValidators: number
+  packages: Array<{ name: string; componentCount: number }>
+} {
+  const packages = Array.from(packageValidators.entries()).map(([name, components]) => ({
+    name,
+    componentCount: components.size
+  }))
+
+  return {
+    totalValidators: pluginValidators.size,
+    packages
+  }
+}
+
+/**
+ * Validate a component using registered validators
+ */
+export function validateComponent(packageName: string, componentName: string, args: unknown[]): void {
+  const validator = getComponentValidator(packageName, componentName)
+  if (validator && validator.validate) {
+    validator.validate(args)
+  }
+}
+
+/**
+ * Check if a component has validation registered
+ */
+export function hasValidator(packageName: string, componentName: string): boolean {
+  return pluginValidators.has(`${packageName}:${componentName}`)
+}
+
+/**
+ * Get all registered packages
+ */
+export function getRegisteredPackages(): string[] {
+  return Array.from(packageValidators.keys())
+}
+
+/**
+ * Get all components for a package
+ */
+export function getPackageComponents(packageName: string): string[] {
+  const components = packageValidators.get(packageName)
+  return components ? Array.from(components) : []
+}
+
+/**
+ * Clear all validators (for testing/cleanup)
+ */
+export function clearAllValidators(): void {
+  pluginValidators.clear()
+  packageValidators.clear()
+
+  if (process.env.NODE_ENV !== 'production') {
+    console.info('🔍 Cleared all plugin validators')
+  }
+}
+
+/**
+ * Plugin helper for easier registration
+ */
+export const PluginValidationHelper = {
+  /**
+   * Register a simple plugin with basic validation
+   */
+  registerPlugin(
+    packageName: string,
+    components: Array<{
+      name: string
+      requiredProps?: string[]
+      optionalProps?: string[]
+    }>
+  ): void {
+    registerPluginValidation({
+      packageName,
+      components: components.map(comp => ({
+        name: comp.name,
+        requiredProps: comp.requiredProps,
+        optionalProps: comp.optionalProps
+      }))
+    })
+  },
+
+  /**
+   * Create a custom validator
+   */
+  createValidator(
+    packageName: string,
+    componentName: string,
+    validate: (args: unknown[]) => void
+  ): ComponentValidator {
+    return {
+      packageName,
+      componentName,
+      validate
+    }
+  }
+}

package/src/validation/production-bypass.ts

@@ -0,0 +1,466 @@
+/**
+ * Production Mode Bypass System - Phase 1C
+ * 
+ * Zero-overhead validation bypass for production builds with smart
+ * compile-time elimination and runtime optimization.
+ */
+
+import type { ComponentInstance } from '../runtime/types'
+
+/**
+ * Production mode detection and configuration
+ */
+export interface ProductionConfig {
+  enabled: boolean
+  mode: 'development' | 'production' | 'test'
+  optimizationLevel: 'none' | 'basic' | 'aggressive'
+  debugInfo: boolean
+}
+
+/**
+ * Global production configuration
+ */
+let productionConfig: ProductionConfig = {
+  enabled: process.env.NODE_ENV === 'production',
+  mode: (process.env.NODE_ENV as any) || 'development',
+  optimizationLevel: process.env.NODE_ENV === 'production' ? 'aggressive' : 'basic',
+  debugInfo: process.env.NODE_ENV !== 'production'
+}
+
+/**
+ * Production mode utilities
+ */
+export class ProductionModeManager {
+  private static validationDisabled = false
+  private static bypassCount = 0
+  private static performanceGain = 0
+
+  /**
+   * Check if we're in production mode
+   */
+  static isProduction(): boolean {
+    return productionConfig.enabled || process.env.NODE_ENV === 'production'
+  }
+
+  /**
+   * Check if validation should be bypassed
+   */
+  static shouldBypassValidation(): boolean {
+    // Always bypass in production
+    if (this.isProduction()) {
+      this.bypassCount++
+      return true
+    }
+
+    // Check if manually disabled
+    if (this.validationDisabled) {
+      this.bypassCount++
+      return true
+    }
+
+    // Check environment variable override
+    if (process.env.TACHUI_VALIDATION === 'false') {
+      this.bypassCount++
+      return true
+    }
+
+    return false
+  }
+
+  /**
+   * Manually disable validation (for testing/debugging)
+   */
+  static disableValidation(): void {
+    this.validationDisabled = true
+    if (productionConfig.debugInfo) {
+      console.info('🚫 TachUI validation manually disabled')
+    }
+  }
+
+  /**
+   * Re-enable validation (only works in development)
+   */
+  static enableValidation(): void {
+    if (this.isProduction()) {
+      console.warn('⚠️ Cannot enable validation in production mode')
+      return
+    }
+    
+    this.validationDisabled = false
+    if (productionConfig.debugInfo) {
+      console.info('✅ TachUI validation re-enabled')
+    }
+  }
+
+  /**
+   * Get bypass statistics
+   */
+  static getBypassStats() {
+    return {
+      mode: productionConfig.mode,
+      bypassCount: this.bypassCount,
+      validationDisabled: this.validationDisabled,
+      performanceGain: this.performanceGain,
+      optimizationLevel: productionConfig.optimizationLevel
+    }
+  }
+
+  /**
+   * Configure production mode settings
+   */
+  static configure(config: Partial<ProductionConfig>): void {
+    productionConfig = { ...productionConfig, ...config }
+    
+    if (config.enabled !== undefined) {
+      this.validationDisabled = !config.enabled
+    }
+  }
+
+  /**
+   * Measure performance gain from bypassing validation
+   */
+  static recordPerformanceGain(timeMs: number): void {
+    this.performanceGain += timeMs
+  }
+}
+
+/**
+ * Zero-overhead function wrapper for production builds
+ */
+export function createProductionOptimizedFunction<T extends (...args: any[]) => any>(
+  developmentFunction: T,
+  productionFunction?: T
+): T {
+  // If we have a specific production function, use it
+  if (productionFunction && ProductionModeManager.isProduction()) {
+    return productionFunction
+  }
+
+  // Return optimized wrapper
+  return ((...args: any[]) => {
+    if (ProductionModeManager.shouldBypassValidation()) {
+      // In production, try to use the production function or skip entirely
+      if (productionFunction) {
+        return productionFunction(...args)
+      }
+      
+      // If no production function, return a no-op that matches expected signature
+      // This should be tree-shaken out by bundlers in production
+      return undefined
+    }
+
+    // Development mode - run full function
+    return developmentFunction(...args)
+  }) as T
+}
+
+/**
+ * Component constructor wrapper with production optimization
+ */
+export function createOptimizedComponent<T extends ComponentInstance>(
+  originalConstructor: (...args: any[]) => T,
+  validator?: (args: unknown[]) => void,
+  componentType?: string
+): (...args: any[]) => T {
+  
+  // In production, return the original constructor without validation
+  if (ProductionModeManager.isProduction()) {
+    return originalConstructor
+  }
+
+  // Development mode with validation
+  return function optimizedComponent(this: any, ...args: unknown[]): T {
+    const startTime = performance.now()
+    
+    // Skip validation if bypassed
+    if (ProductionModeManager.shouldBypassValidation()) {
+      const endTime = performance.now()
+      ProductionModeManager.recordPerformanceGain(endTime - startTime)
+      return originalConstructor.apply(this, args as any)
+    }
+
+    // Run validation in development
+    if (validator) {
+      try {
+        validator(args)
+      } catch (error) {
+        // In development, provide detailed error information
+        if (productionConfig.debugInfo && componentType) {
+          console.error(`Validation failed for ${componentType}:`, error)
+        }
+        throw error
+      }
+    }
+
+    const result = originalConstructor.apply(this, args as any)
+    const endTime = performance.now()
+    
+    // Record validation overhead for monitoring
+    const overhead = endTime - startTime
+    if (overhead > 5) { // More than 5ms is concerning
+      console.warn(`⚠️ Validation overhead: ${overhead.toFixed(2)}ms for ${componentType || 'component'}`)
+    }
+
+    return result
+  }
+}
+
+/**
+ * Modifier validation wrapper with production bypass
+ */
+export function createOptimizedModifier(
+  originalModifier: Function,
+  validator?: (args: unknown[]) => void,
+  modifierName?: string
+): Function {
+  
+  // In production, return original modifier without validation
+  if (ProductionModeManager.isProduction()) {
+    return originalModifier
+  }
+
+  return function optimizedModifier(this: any, ...args: unknown[]) {
+    // Skip validation if bypassed
+    if (ProductionModeManager.shouldBypassValidation()) {
+      return originalModifier.apply(this, args)
+    }
+
+    // Run validation in development
+    if (validator) {
+      try {
+        validator(args)
+      } catch (error) {
+        if (productionConfig.debugInfo && modifierName) {
+          console.error(`Modifier validation failed for ${modifierName}:`, error)
+        }
+        throw error
+      }
+    }
+
+    return originalModifier.apply(this, args)
+  }
+}
+
+/**
+ * Build-time optimization hints for bundlers
+ */
+export const BuildOptimizationHints = {
+  /**
+   * Mark validation code for tree-shaking in production
+   */
+  __DEVELOPMENT_ONLY__: process.env.NODE_ENV !== 'production',
+  
+  /**
+   * Webpack DefinePlugin constants for dead code elimination
+   */
+  WEBPACK_DEFINES: {
+    '__TACHUI_VALIDATION_ENABLED__': process.env.NODE_ENV !== 'production',
+    '__TACHUI_PRODUCTION_MODE__': process.env.NODE_ENV === 'production',
+    '__TACHUI_DEBUG_INFO__': process.env.NODE_ENV !== 'production'
+  },
+  
+  /**
+   * Rollup/Vite constants for dead code elimination
+   */
+  VITE_DEFINES: {
+    'import.meta.env.TACHUI_VALIDATION': process.env.NODE_ENV !== 'production',
+    'import.meta.env.TACHUI_PRODUCTION': process.env.NODE_ENV === 'production'
+  }
+}
+
+/**
+ * Conditional validation macro for tree-shaking
+ */
+export function conditionalValidation<T>(
+  validationFn: () => T,
+  fallbackValue?: T
+): T | undefined {
+  // This will be completely removed in production builds by bundlers
+  if (process.env.NODE_ENV !== 'production' && !ProductionModeManager.shouldBypassValidation()) {
+    return validationFn()
+  }
+  
+  return fallbackValue
+}
+
+/**
+ * Development-only assertion macro
+ */
+export function devAssert(condition: boolean, message: string): void {
+  // Tree-shaken out in production
+  if (process.env.NODE_ENV !== 'production') {
+    if (!condition && !ProductionModeManager.shouldBypassValidation()) {
+      throw new Error(`TachUI Dev Assertion: ${message}`)
+    }
+  }
+}
+
+/**
+ * Development-only warning macro
+ */
+export function devWarn(condition: boolean, message: string): void {
+  // Tree-shaken out in production
+  if (process.env.NODE_ENV !== 'production') {
+    if (!condition && !ProductionModeManager.shouldBypassValidation()) {
+      console.warn(`TachUI Dev Warning: ${message}`)
+    }
+  }
+}
+
+/**
+ * Performance monitoring wrapper
+ */
+export function withPerformanceMonitoring<T extends (...args: any[]) => any>(
+  fn: T,
+  name: string
+): T {
+  // In production, return function without monitoring
+  if (ProductionModeManager.isProduction()) {
+    return fn
+  }
+
+  return ((...args: any[]) => {
+    if (ProductionModeManager.shouldBypassValidation()) {
+      return fn(...args)
+    }
+
+    const start = performance.now()
+    const result = fn(...args)
+    const end = performance.now()
+    
+    const duration = end - start
+    if (duration > 10) { // More than 10ms is worth noting
+      console.info(`⏱️ ${name}: ${duration.toFixed(2)}ms`)
+    }
+    
+    return result
+  }) as T
+}
+
+/**
+ * Bundle size analysis helper
+ */
+export const BundleAnalysis = {
+  /**
+   * Estimate validation code size for bundle analysis
+   */
+  getValidationCodeSize(): number {
+    // This would be replaced with actual measurements in a real implementation
+    const estimatedSize = {
+      validation: 15000, // ~15KB
+      errorReporting: 8000, // ~8KB
+      enhancedRuntime: 12000, // ~12KB
+      total: 35000 // ~35KB total
+    }
+    
+    return ProductionModeManager.isProduction() ? 0 : estimatedSize.total
+  },
+
+  /**
+   * Get optimization report
+   */
+  getOptimizationReport() {
+    const stats = ProductionModeManager.getBypassStats()
+    const codeSize = this.getValidationCodeSize()
+    
+    return {
+      mode: stats.mode,
+      validationCodeSize: codeSize,
+      bypassCount: stats.bypassCount,
+      performanceGain: stats.performanceGain,
+      optimization: codeSize === 0 ? 'Fully optimized (tree-shaken)' : 'Development mode',
+      recommendations: this.getOptimizationRecommendations()
+    }
+  },
+
+  /**
+   * Get optimization recommendations
+   */
+  getOptimizationRecommendations(): string[] {
+    const recommendations: string[] = []
+    
+    if (!ProductionModeManager.isProduction()) {
+      recommendations.push('Enable production mode (NODE_ENV=production) to remove validation code')
+    }
+    
+    if (productionConfig.optimizationLevel !== 'aggressive') {
+      recommendations.push('Use aggressive optimization level for maximum performance')
+    }
+    
+    if (process.env.TACHUI_VALIDATION !== 'false') {
+      recommendations.push('Consider setting TACHUI_VALIDATION=false for production if not needed')
+    }
+    
+    return recommendations
+  }
+}
+
+/**
+ * Production optimization utilities
+ */
+export const ProductionOptimizationUtils = {
+  /**
+   * Configure production mode
+   */
+  configure: ProductionModeManager.configure,
+  
+  /**
+   * Check if in production
+   */
+  isProduction: ProductionModeManager.isProduction,
+  
+  /**
+   * Manually disable validation
+   */
+  disableValidation: ProductionModeManager.disableValidation,
+  
+  /**
+   * Re-enable validation (development only)
+   */
+  enableValidation: ProductionModeManager.enableValidation,
+  
+  /**
+   * Get performance statistics
+   */
+  getStats: ProductionModeManager.getBypassStats,
+  
+  /**
+   * Get bundle optimization report
+   */
+  getBundleReport: BundleAnalysis.getOptimizationReport,
+  
+  /**
+   * Test production optimization
+   */
+  test(): void {
+    console.group('🚀 Production Optimization Test')
+    
+    const stats = ProductionModeManager.getBypassStats()
+    const report = BundleAnalysis.getOptimizationReport()
+    
+    console.info('✅ Production mode detection:', ProductionModeManager.isProduction())
+    console.info('✅ Validation bypass count:', stats.bypassCount)
+    console.info('✅ Performance gain:', `${stats.performanceGain.toFixed(2)}ms`)
+    console.info('✅ Bundle optimization:', report.optimization)
+    console.info('✅ Code size:', report.validationCodeSize === 0 ? 'Removed' : `${report.validationCodeSize} bytes`)
+    
+    if (report.recommendations.length > 0) {
+      console.info('💡 Recommendations:')
+      report.recommendations.forEach(rec => console.info(`   • ${rec}`))
+    }
+    
+    console.groupEnd()
+  }
+}
+
+// Auto-configure based on environment
+if (typeof window !== 'undefined') {
+  // Browser environment
+  const isProduction = !window.location.hostname.includes('localhost') && 
+                      !window.location.hostname.includes('127.0.0.1') &&
+                      !window.location.hostname.includes('dev')
+  
+  if (isProduction) {
+    ProductionModeManager.configure({ enabled: true, mode: 'production' })
+  }
+}