@3fn/core 14.1.0 → 15.0.0

package/src/integration/BuildSystemInterface.ts

@@ -1,338 +0,0 @@
-/**
- * Build System Integration Interface
- * 
- * Provides standardized interface for integrating the Mathematical Token System
- * with various build systems (webpack, rollup, vite, etc.). Enables seamless
- * platform file selection and build-time optimization.
- */
-
-import type { TranslationOutput } from '../types';
-
-/**
- * Supported build systems
- */
-export type BuildSystem = 'webpack' | 'rollup' | 'vite' | 'esbuild' | 'parcel' | 'custom';
-
-/**
- * Target platform for build output
- */
-export type TargetPlatform = 'web' | 'ios' | 'android';
-
-/**
- * Build system configuration
- */
-export interface BuildSystemConfig {
-  /** Build system type */
-  system: BuildSystem;
-  
-  /** Target platform(s) for this build */
-  targets: TargetPlatform[];
-  
-  /** Enable tree-shaking optimization */
-  treeShaking?: boolean;
-  
-  /** Output directory for generated token files */
-  outputDir?: string;
-  
-  /** Enable source maps for debugging */
-  sourceMaps?: boolean;
-  
-  /** Custom file naming pattern */
-  filePattern?: string;
-  
-  /** Additional build system specific options */
-  customOptions?: Record<string, unknown>;
-}
-
-/**
- * Build integration result
- */
-export interface BuildIntegrationResult {
-  /** Whether integration was successful */
-  success: boolean;
-  
-  /** Generated files for the build */
-  files: TranslationOutput[];
-  
-  /** Platform-specific entry points */
-  entryPoints: Map<TargetPlatform, string>;
-  
-  /** Build system specific configuration */
-  buildConfig: Record<string, unknown>;
-  
-  /** Any warnings during integration */
-  warnings: string[];
-  
-  /** Error message if integration failed */
-  error?: string;
-}
-
-/**
- * Build system integration interface
- * 
- * Provides methods for integrating token generation with build systems,
- * enabling platform-specific file selection and optimization.
- */
-export interface IBuildSystemIntegration {
-  /**
-   * Configure the build system integration
-   */
-  configure(config: BuildSystemConfig): void;
-  
-  /**
-   * Generate platform-specific token files for the build
-   */
-  generateForBuild(platforms: TargetPlatform[]): Promise<BuildIntegrationResult>;
-  
-  /**
-   * Get entry point for a specific platform
-   */
-  getEntryPoint(platform: TargetPlatform): string;
-  
-  /**
-   * Get build system specific configuration
-   */
-  getBuildConfig(): Record<string, unknown>;
-  
-  /**
-   * Validate build configuration
-   */
-  validateConfig(config: BuildSystemConfig): { valid: boolean; errors: string[] };
-}
-
-/**
- * Build system integration implementation
- */
-export class BuildSystemIntegration implements IBuildSystemIntegration {
-  private config: BuildSystemConfig | null = null;
-  private generatedFiles: Map<TargetPlatform, TranslationOutput> = new Map();
-
-  configure(config: BuildSystemConfig): void {
-    const validation = this.validateConfig(config);
-    if (!validation.valid) {
-      throw new Error(`Invalid build configuration: ${validation.errors.join(', ')}`);
-    }
-    this.config = config;
-  }
-
-  async generateForBuild(platforms: TargetPlatform[]): Promise<BuildIntegrationResult> {
-    if (!this.config) {
-      return {
-        success: false,
-        files: [],
-        entryPoints: new Map(),
-        buildConfig: {},
-        warnings: [],
-        error: 'Build system not configured. Call configure() first.'
-      };
-    }
-
-    const warnings: string[] = [];
-    const files: TranslationOutput[] = [];
-    const entryPoints = new Map<TargetPlatform, string>();
-
-    try {
-      // Generate files for each platform
-      for (const platform of platforms) {
-        const file = await this.generatePlatformFile(platform);
-        files.push(file);
-        this.generatedFiles.set(platform, file);
-        entryPoints.set(platform, file.filePath);
-      }
-
-      // Generate build system specific configuration
-      const buildConfig = this.generateBuildConfig(platforms);
-
-      return {
-        success: true,
-        files,
-        entryPoints,
-        buildConfig,
-        warnings
-      };
-    } catch (error) {
-      return {
-        success: false,
-        files,
-        entryPoints,
-        buildConfig: {},
-        warnings,
-        error: error instanceof Error ? error.message : 'Unknown error during build integration'
-      };
-    }
-  }
-
-  getEntryPoint(platform: TargetPlatform): string {
-    const file = this.generatedFiles.get(platform);
-    if (!file) {
-      throw new Error(`No entry point found for platform: ${platform}. Generate files first.`);
-    }
-    return file.filePath;
-  }
-
-  getBuildConfig(): Record<string, unknown> {
-    if (!this.config) {
-      throw new Error('Build system not configured. Call configure() first.');
-    }
-    return this.generateBuildConfig(this.config.targets);
-  }
-
-  validateConfig(config: BuildSystemConfig): { valid: boolean; errors: string[] } {
-    const errors: string[] = [];
-
-    if (!config.system) {
-      errors.push('Build system type is required');
-    }
-
-    if (!config.targets || config.targets.length === 0) {
-      errors.push('At least one target platform is required');
-    }
-
-    if (config.targets) {
-      const validPlatforms: TargetPlatform[] = ['web', 'ios', 'android'];
-      for (const target of config.targets) {
-        if (!validPlatforms.includes(target)) {
-          errors.push(`Invalid target platform: ${target}`);
-        }
-      }
-    }
-
-    if (config.outputDir && typeof config.outputDir !== 'string') {
-      errors.push('Output directory must be a string');
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-
-  private async generatePlatformFile(platform: TargetPlatform): Promise<TranslationOutput> {
-    // This would integrate with TranslationCoordinator in real implementation
-    // For now, return a mock structure
-    const fileExtensions: Record<TargetPlatform, string> = {
-      web: 'css',
-      ios: 'swift',
-      android: 'kt'
-    };
-
-    const formats: Record<TargetPlatform, TranslationOutput['format']> = {
-      web: 'css',
-      ios: 'swift',
-      android: 'kotlin'
-    };
-
-    const outputDir = this.config?.outputDir || 'dist/tokens';
-    const filePattern = this.config?.filePattern || 'DesignTokens.{platform}.{ext}';
-    
-    const fileName = filePattern
-      .replace('{platform}', platform)
-      .replace('{ext}', fileExtensions[platform]);
-
-    return {
-      platform,
-      filePath: `${outputDir}/${fileName}`,
-      content: `// Generated tokens for ${platform}`,
-      format: formats[platform],
-      tokenCount: 0,
-      validationStatus: 'valid'
-    };
-  }
-
-  private generateBuildConfig(platforms: TargetPlatform[]): Record<string, unknown> {
-    if (!this.config) {
-      return {};
-    }
-
-    const { system, treeShaking, sourceMaps } = this.config;
-
-    switch (system) {
-      case 'webpack':
-        return this.generateWebpackConfig(platforms, treeShaking, sourceMaps);
-      case 'rollup':
-        return this.generateRollupConfig(platforms, treeShaking, sourceMaps);
-      case 'vite':
-        return this.generateViteConfig(platforms, treeShaking, sourceMaps);
-      case 'esbuild':
-        return this.generateEsbuildConfig(platforms, treeShaking, sourceMaps);
-      default:
-        return {};
-    }
-  }
-
-  private generateWebpackConfig(
-    platforms: TargetPlatform[],
-    treeShaking?: boolean,
-    sourceMaps?: boolean
-  ): Record<string, unknown> {
-    return {
-      resolve: {
-        alias: this.generateAliases(platforms)
-      },
-      optimization: {
-        usedExports: treeShaking !== false,
-        sideEffects: false
-      },
-      devtool: sourceMaps ? 'source-map' : false
-    };
-  }
-
-  private generateRollupConfig(
-    platforms: TargetPlatform[],
-    treeShaking?: boolean,
-    sourceMaps?: boolean
-  ): Record<string, unknown> {
-    return {
-      treeshake: treeShaking !== false,
-      sourcemap: sourceMaps !== false,
-      external: this.generateExternals(platforms)
-    };
-  }
-
-  private generateViteConfig(
-    platforms: TargetPlatform[],
-    treeShaking?: boolean,
-    sourceMaps?: boolean
-  ): Record<string, unknown> {
-    return {
-      resolve: {
-        alias: this.generateAliases(platforms)
-      },
-      build: {
-        sourcemap: sourceMaps !== false,
-        rollupOptions: {
-          treeshake: treeShaking !== false
-        }
-      }
-    };
-  }
-
-  private generateEsbuildConfig(
-    platforms: TargetPlatform[],
-    treeShaking?: boolean,
-    sourceMaps?: boolean
-  ): Record<string, unknown> {
-    return {
-      alias: this.generateAliases(platforms),
-      treeShaking: treeShaking !== false,
-      sourcemap: sourceMaps !== false
-    };
-  }
-
-  private generateAliases(platforms: TargetPlatform[]): Record<string, string> {
-    const aliases: Record<string, string> = {};
-    
-    for (const platform of platforms) {
-      const file = this.generatedFiles.get(platform);
-      if (file) {
-        aliases[`@tokens/${platform}`] = file.filePath;
-      }
-    }
-
-    return aliases;
-  }
-
-  private generateExternals(platforms: TargetPlatform[]): string[] {
-    return platforms.map(platform => `@tokens/${platform}`);
-  }
-}

package/src/integration/PlatformFileSelector.ts

@@ -1,288 +0,0 @@
-/**
- * Platform File Selector
- * 
- * Provides intelligent platform file selection for build systems, enabling
- * seamless integration with cross-platform builds. Automatically selects
- * appropriate token files based on build target and environment.
- */
-
-import type { TargetPlatform } from './BuildSystemInterface';
-import type { TranslationOutput } from '../types';
-
-/**
- * Platform detection strategy
- */
-export type PlatformDetectionStrategy = 
-  | 'explicit'      // Platform explicitly specified
-  | 'environment'   // Detect from environment variables
-  | 'package'       // Detect from package.json
-  | 'auto';         // Automatic detection using multiple strategies
-
-/**
- * Platform selection options
- */
-export interface PlatformSelectionOptions {
-  /** Detection strategy to use */
-  strategy?: PlatformDetectionStrategy;
-  
-  /** Fallback platform if detection fails */
-  fallback?: TargetPlatform;
-  
-  /** Custom environment variable name for platform detection */
-  envVar?: string;
-  
-  /** Enable strict mode (throw error if platform cannot be determined) */
-  strict?: boolean;
-}
-
-/**
- * Platform selection result
- */
-export interface PlatformSelectionResult {
-  /** Selected platform */
-  platform: TargetPlatform;
-  
-  /** Detection strategy that was used */
-  strategyUsed: PlatformDetectionStrategy;
-  
-  /** Whether fallback was used */
-  usedFallback: boolean;
-  
-  /** Confidence level (0-1) in the selection */
-  confidence: number;
-  
-  /** Additional context about the selection */
-  context: string;
-}
-
-/**
- * Platform file selector
- * 
- * Intelligently selects appropriate platform-specific token files based on
- * build context, environment, and configuration.
- */
-export class PlatformFileSelector {
-  private availableFiles: Map<TargetPlatform, TranslationOutput> = new Map();
-  private options: Required<PlatformSelectionOptions>;
-
-  constructor(options: PlatformSelectionOptions = {}) {
-    this.options = {
-      strategy: options.strategy || 'auto',
-      fallback: options.fallback || 'web',
-      envVar: options.envVar || 'TARGET_PLATFORM',
-      strict: options.strict || false
-    };
-  }
-
-  /**
-   * Register available platform files
-   */
-  registerFiles(files: TranslationOutput[]): void {
-    for (const file of files) {
-      this.availableFiles.set(file.platform, file);
-    }
-  }
-
-  /**
-   * Select platform based on configuration and context
-   */
-  selectPlatform(explicitPlatform?: TargetPlatform): PlatformSelectionResult {
-    // Strategy 1: Explicit platform specified
-    if (explicitPlatform) {
-      return this.selectExplicit(explicitPlatform);
-    }
-
-    // Strategy 2: Use configured strategy
-    switch (this.options.strategy) {
-      case 'explicit':
-        return this.handleMissingExplicit();
-      case 'environment':
-        return this.selectFromEnvironment();
-      case 'package':
-        return this.selectFromPackage();
-      case 'auto':
-        return this.selectAuto();
-      default:
-        return this.selectFallback('Unknown strategy');
-    }
-  }
-
-  /**
-   * Get file path for selected platform
-   */
-  getFilePath(platform: TargetPlatform): string {
-    const file = this.availableFiles.get(platform);
-    if (!file) {
-      if (this.options.strict) {
-        throw new Error(`No file available for platform: ${platform}`);
-      }
-      // Return fallback
-      const fallbackFile = this.availableFiles.get(this.options.fallback);
-      if (!fallbackFile) {
-        throw new Error(`No file available for fallback platform: ${this.options.fallback}`);
-      }
-      return fallbackFile.filePath;
-    }
-    return file.filePath;
-  }
-
-  /**
-   * Get all available platforms
-   */
-  getAvailablePlatforms(): TargetPlatform[] {
-    return Array.from(this.availableFiles.keys());
-  }
-
-  /**
-   * Check if platform is available
-   */
-  isPlatformAvailable(platform: TargetPlatform): boolean {
-    return this.availableFiles.has(platform);
-  }
-
-  private selectExplicit(platform: TargetPlatform): PlatformSelectionResult {
-    if (!this.isPlatformAvailable(platform)) {
-      if (this.options.strict) {
-        throw new Error(`Platform not available: ${platform}`);
-      }
-      return this.selectFallback(`Explicit platform ${platform} not available`);
-    }
-
-    return {
-      platform,
-      strategyUsed: 'explicit',
-      usedFallback: false,
-      confidence: 1.0,
-      context: `Explicitly specified platform: ${platform}`
-    };
-  }
-
-  private handleMissingExplicit(): PlatformSelectionResult {
-    if (this.options.strict) {
-      throw new Error('Explicit platform required but not provided');
-    }
-    return this.selectFallback('No explicit platform provided');
-  }
-
-  private selectFromEnvironment(): PlatformSelectionResult {
-    const envPlatform = process.env[this.options.envVar];
-    
-    if (!envPlatform) {
-      if (this.options.strict) {
-        throw new Error(`Environment variable ${this.options.envVar} not set`);
-      }
-      return this.selectFallback(`Environment variable ${this.options.envVar} not set`);
-    }
-
-    const platform = this.normalizePlatform(envPlatform);
-    if (!platform) {
-      if (this.options.strict) {
-        throw new Error(`Invalid platform in environment: ${envPlatform}`);
-      }
-      return this.selectFallback(`Invalid platform in environment: ${envPlatform}`);
-    }
-
-    if (!this.isPlatformAvailable(platform)) {
-      if (this.options.strict) {
-        throw new Error(`Platform from environment not available: ${platform}`);
-      }
-      return this.selectFallback(`Platform from environment not available: ${platform}`);
-    }
-
-    return {
-      platform,
-      strategyUsed: 'environment',
-      usedFallback: false,
-      confidence: 0.9,
-      context: `Detected from environment variable ${this.options.envVar}=${envPlatform}`
-    };
-  }
-
-  private selectFromPackage(): PlatformSelectionResult {
-    // In a real implementation, this would read package.json
-    // For now, return fallback
-    if (this.options.strict) {
-      throw new Error('Package.json detection not implemented');
-    }
-    return this.selectFallback('Package.json detection not implemented');
-  }
-
-  private selectAuto(): PlatformSelectionResult {
-    // Try environment first
-    const envPlatform = process.env[this.options.envVar];
-    if (envPlatform) {
-      const platform = this.normalizePlatform(envPlatform);
-      if (platform && this.isPlatformAvailable(platform)) {
-        return {
-          platform,
-          strategyUsed: 'environment',
-          usedFallback: false,
-          confidence: 0.9,
-          context: `Auto-detected from environment variable ${this.options.envVar}=${envPlatform}`
-        };
-      }
-    }
-
-    // Try common environment indicators
-    const nodeEnv = process.env.NODE_ENV;
-    if (nodeEnv === 'production' || nodeEnv === 'development') {
-      // Assume web for Node.js environments
-      if (this.isPlatformAvailable('web')) {
-        return {
-          platform: 'web',
-          strategyUsed: 'environment',
-          usedFallback: false,
-          confidence: 0.7,
-          context: `Auto-detected web platform from NODE_ENV=${nodeEnv}`
-        };
-      }
-    }
-
-    // Use fallback
-    return this.selectFallback('Auto-detection failed, no clear platform indicators');
-  }
-
-  private selectFallback(reason: string): PlatformSelectionResult {
-    const fallback = this.options.fallback;
-    
-    if (!this.isPlatformAvailable(fallback)) {
-      throw new Error(`Fallback platform not available: ${fallback}`);
-    }
-
-    return {
-      platform: fallback,
-      strategyUsed: this.options.strategy,
-      usedFallback: true,
-      confidence: 0.5,
-      context: `Using fallback platform (${fallback}): ${reason}`
-    };
-  }
-
-  private normalizePlatform(value: string): TargetPlatform | null {
-    const normalized = value.toLowerCase().trim();
-    
-    const platformMap: Record<string, TargetPlatform> = {
-      'web': 'web',
-      'browser': 'web',
-      'js': 'web',
-      'javascript': 'web',
-      'ios': 'ios',
-      'swift': 'ios',
-      'apple': 'ios',
-      'android': 'android',
-      'kotlin': 'android',
-      'java': 'android'
-    };
-
-    return platformMap[normalized] || null;
-  }
-}
-
-/**
- * Create a platform file selector with default options
- */
-export function createPlatformSelector(
-  options?: PlatformSelectionOptions
-): PlatformFileSelector {
-  return new PlatformFileSelector(options);
-}