css2class 2.0.0

package/src/core/CompatibilityAdapter.js

@@ -0,0 +1,264 @@
+const ConfigValidator = require('./ConfigValidator');
+
+class CompatibilityAdapter {
+  constructor(eventBus, configValidator) {
+    this.eventBus = eventBus;
+    this.configValidator = configValidator || new ConfigValidator(eventBus);
+  }
+
+  // 将旧配置格式转换为新格式
+  adaptConfig(config) {
+    try {
+      // 如果已经是新格式，直接返回
+      if (this.isNewFormat(config)) {
+        return config;
+      }
+
+      // 转换为新格式
+      const adaptedConfig = this.transformToNewFormat(config);
+
+      // 验证转换后的配置
+      const validation = this.configValidator.validateConfig(adaptedConfig);
+      if (!validation.isValid) {
+        this.eventBus.emit('compatibility:validation:failed', {
+          errors: validation.errors,
+          warnings: validation.warnings,
+        });
+      }
+
+      this.eventBus.emit('compatibility:adapted', {
+        original: config,
+        adapted: adaptedConfig,
+        validation,
+      });
+
+      return adaptedConfig;
+    } catch (error) {
+      this.eventBus.emit('compatibility:error', error);
+      throw error;
+    }
+  }
+
+  // 检查是否为新格式
+  isNewFormat(config) {
+    // 检查是否有新的system配置结构
+    return !!(config.system || config.atomicRules || config.compatibility);
+  }
+
+  // 转换为新格式
+  transformToNewFormat(config) {
+    const newConfig = {
+      // 系统配置
+      system: {
+        baseUnit: config.baseUnit || 'px',
+        unitConversion: config.unitConversion || 1,
+        compression: config.compression !== undefined ? config.compression : true,
+        unitStrategy: {
+          autoDetect: true,
+          propertyUnits: {
+            'font-size': config.baseUnit || 'px',
+            'width|height': config.baseUnit || 'px',
+            opacity: '',
+            'z-index': '',
+            'line-height': '',
+            'border-radius': config.baseUnit || 'px',
+          },
+        },
+      },
+
+      // 保留现有配置
+      output: config.output,
+      importantFlags: config.importantFlags,
+      multiFile: config.multiFile,
+
+      // 保留原有配置结构以确保兼容性
+      cssName: config.cssName,
+      baseClassName: config.baseClassName,
+      atomicClassMap: config.atomicClassMap,
+      variants: config.variants,
+
+      // 兼容性配置
+      compatibility: {
+        legacy: {
+          cssName: config.cssName,
+          baseClassName: config.baseClassName,
+          atomicClassMap: config.atomicClassMap,
+        },
+        unified: {
+          enabled: false, // 默认关闭新功能
+        },
+      },
+    };
+
+    return newConfig;
+  }
+
+  // 合并配置
+  mergeConfigs(baseConfig, overrideConfig) {
+    const merged = JSON.parse(JSON.stringify(baseConfig));
+
+    // 深度合并
+    this.deepMerge(merged, overrideConfig);
+
+    return merged;
+  }
+
+  // 深度合并对象
+  deepMerge(target, source) {
+    for (const key in source) {
+      if (source.hasOwnProperty(key)) {
+        if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+          if (!target[key] || typeof target[key] !== 'object') {
+            target[key] = {};
+          }
+          this.deepMerge(target[key], source[key]);
+        } else {
+          target[key] = source[key];
+        }
+      }
+    }
+  }
+
+  // 解决配置冲突
+  resolveConflicts(config) {
+    const resolved = JSON.parse(JSON.stringify(config));
+    let hasChanges = false;
+
+    // 解决text属性冲突
+    if (resolved.cssName?.text && resolved.atomicClassMap?.text) {
+      // 保留atomicClassMap中的定义，在cssName中重命名
+      resolved.cssName.textSize = resolved.cssName.text;
+      delete resolved.cssName.text;
+      hasChanges = true;
+
+      this.eventBus.emit('compatibility:conflict:resolved', {
+        type: 'text_property_conflict',
+        action: 'renamed cssName.text to cssName.textSize',
+      });
+    }
+
+    // 解决重复的间距定义
+    const spacingConflicts = this.findSpacingConflicts(resolved);
+    if (spacingConflicts.length > 0) {
+      this.resolveSpacingConflicts(resolved, spacingConflicts);
+      hasChanges = true;
+    }
+
+    return { config: resolved, hasChanges };
+  }
+
+  // 查找间距配置冲突
+  findSpacingConflicts(config) {
+    const conflicts = [];
+    const spacingProps = [
+      'm',
+      'mt',
+      'mr',
+      'mb',
+      'ml',
+      'mx',
+      'my',
+      'p',
+      'pt',
+      'pr',
+      'pb',
+      'pl',
+      'px',
+      'py',
+    ];
+
+    spacingProps.forEach((prop) => {
+      const sources = [];
+      if (config.cssName?.[prop]) sources.push('cssName');
+      if (config.atomicClassMap?.[prop]) sources.push('atomicClassMap');
+
+      if (sources.length > 1) {
+        conflicts.push({ property: prop, sources });
+      }
+    });
+
+    return conflicts;
+  }
+
+  // 解决间距配置冲突
+  resolveSpacingConflicts(config, conflicts) {
+    conflicts.forEach((conflict) => {
+      // 优先使用atomicClassMap的定义
+      if (config.cssName[conflict.property] && config.atomicClassMap[conflict.property]) {
+        delete config.cssName[conflict.property];
+
+        this.eventBus.emit('compatibility:conflict:resolved', {
+          type: 'spacing_conflict',
+          property: conflict.property,
+          action: 'removed from cssName, kept in atomicClassMap',
+        });
+      }
+    });
+  }
+
+  // 创建向后兼容的配置视图
+  createLegacyView(modernConfig) {
+    return {
+      baseUnit: modernConfig.system?.baseUnit || modernConfig.baseUnit,
+      unitConversion: modernConfig.system?.unitConversion || modernConfig.unitConversion,
+      compression: modernConfig.system?.compression || modernConfig.compression,
+      cssName: modernConfig.cssName || modernConfig.compatibility?.legacy?.cssName,
+      baseClassName:
+        modernConfig.baseClassName || modernConfig.compatibility?.legacy?.baseClassName,
+      atomicClassMap:
+        modernConfig.atomicClassMap || modernConfig.compatibility?.legacy?.atomicClassMap,
+      importantFlags: modernConfig.importantFlags,
+      multiFile: modernConfig.multiFile,
+      output: modernConfig.output,
+      variants: modernConfig.variants,
+    };
+  }
+
+  // 生成兼容性报告
+  generateCompatibilityReport(originalConfig, adaptedConfig) {
+    const report = {
+      originalFormat: this.isNewFormat(originalConfig) ? 'modern' : 'legacy',
+      adaptedFormat: 'modern',
+      conflicts: [],
+      warnings: [],
+      recommendations: [],
+    };
+
+    // 检查配置冲突
+    const validation = this.configValidator.validateConfig(adaptedConfig);
+    report.warnings = validation.warnings;
+
+    // 检查text属性冲突
+    if (originalConfig.cssName?.text && originalConfig.atomicClassMap?.text) {
+      report.conflicts.push({
+        type: 'property_conflict',
+        property: 'text',
+        description: 'text property defined in both cssName and atomicClassMap',
+      });
+    }
+
+    // 生成建议
+    if (originalConfig.baseUnit !== adaptedConfig.system?.baseUnit) {
+      report.recommendations.push('Consider using consistent base unit across all configurations');
+    }
+
+    if (!originalConfig.compression && adaptedConfig.system?.compression) {
+      report.recommendations.push(
+        'Compression has been enabled in the adapted configuration for better performance'
+      );
+    }
+
+    return report;
+  }
+
+  // 获取适配器统计信息
+  getStats() {
+    return {
+      adaptationsCount: this.adaptationsCount || 0,
+      conflictsResolved: this.conflictsResolved || 0,
+      lastAdaptation: this.lastAdaptation || null,
+    };
+  }
+}
+
+module.exports = CompatibilityAdapter;

package/src/core/ConfigManager.js

@@ -0,0 +1,431 @@
+const path = require('path');
+
+class ConfigManager {
+  constructor(eventBus, configPath = './class2css.config.js') {
+    this.eventBus = eventBus;
+    this.configPath = configPath;
+    this.config = null;
+    this.importantFlags = null;
+    this.cssNameMap = null;
+    this.baseClassNameMap = null;
+    this.userStaticClassSet = null;
+    this.userBaseClass = null;
+    this.userStaticClass = null;
+    this._fileUtils = null;
+    this._logger = null;
+    this._commonCssCache = null;
+    this.breakpoints = null;
+
+    this.loadConfig();
+  }
+
+  loadConfig() {
+    try {
+      // 解析绝对路径
+      const path = require('path');
+      const absoluteConfigPath = path.resolve(this.configPath);
+      this.configPath = absoluteConfigPath; // 保存绝对路径
+
+      // 清除require缓存以确保重新加载
+      delete require.cache[require.resolve(absoluteConfigPath)];
+      
+      // 清除样式配置文件的缓存（如果存在）
+      try {
+        const stylesConfigPath = path.resolve(path.dirname(absoluteConfigPath), 'styles.config.js');
+        if (require.cache[stylesConfigPath]) {
+          delete require.cache[stylesConfigPath];
+        }
+      } catch (e) {
+        // 样式配置文件不存在或无法解析，忽略
+      }
+      
+      this.config = require(absoluteConfigPath);
+
+      this.updateConfigReferences();
+      this.eventBus.emit('config:loaded', this.config);
+
+      return this.config;
+    } catch (error) {
+      this.eventBus.emit('config:error', error);
+      throw error;
+    }
+  }
+
+  updateConfigReferences() {
+    // 更新基础配置 - 支持新的system配置结构
+    this.baseUnit = this.config.system?.baseUnit || this.config.baseUnit || 'px';
+    this.multiFile = this.config.multiFile;
+
+    // 更新自定义 important 标识
+    this.importantFlags = {
+      prefix: this.config.importantFlags?.prefix || ['!'],
+      suffix: this.config.importantFlags?.suffix || ['_i', '-i'],
+      custom: this.config.importantFlags?.custom || [],
+    };
+
+    // 从atomicRules构建类名映射
+    const cssNameMap = this.buildCssNameMapFromAtomicRules();
+
+    // 获取baseClassName配置
+    const baseClassName = this.config.baseClassName || {};
+
+    // 更新类名配置
+    this.userBaseClass = Object.entries(baseClassName).filter(([k, v]) => typeof v === 'object');
+    this.userStaticClass = Object.entries(baseClassName).filter(([k, v]) => typeof v === 'string');
+
+    // 重建索引和缓存
+    this.cssNameMap = cssNameMap;
+    this.baseClassNameMap = new Map(Object.entries(baseClassName));
+    this.userStaticClassSet = new Set(this.userStaticClass.map(([k]) => k));
+
+    // 清空共用CSS缓存，确保配置变更时重新读取
+    this._commonCssCache = null;
+
+    // 更新 breakpoints 配置（响应式断点）
+    this.updateBreakpoints();
+
+    this.eventBus.emit('config:references:updated');
+  }
+
+  // 更新 breakpoints 配置
+  updateBreakpoints() {
+    // 默认 Tailwind 断点值
+    const defaultBreakpoints = {
+      sm: '640px',
+      md: '768px',
+      lg: '1024px',
+      xl: '1280px',
+      '2xl': '1536px',
+    };
+
+    // 如果配置中有 breakpoints，则合并（用户配置优先）
+    const configBreakpoints = this.config.breakpoints || {};
+    this.breakpoints = { ...defaultBreakpoints, ...configBreakpoints };
+  }
+
+  // 从atomicRules构建cssName格式的映射
+  buildCssNameMapFromAtomicRules() {
+    const cssNameMap = new Map();
+    const atomicRules = this.config.atomicRules || {};
+
+    // 遍历所有规则类别
+    Object.values(atomicRules).forEach((category) => {
+      Object.entries(category).forEach(([className, rule]) => {
+        // 转换新格式到旧格式以保持兼容
+        const legacyFormat = {
+          classArr: rule.properties || [],
+          unit: rule.defaultUnit || '',
+          skipConversion: rule.skipConversion || false,
+        };
+        cssNameMap.set(className, legacyFormat);
+      });
+    });
+
+    return cssNameMap;
+  }
+
+  // 配置获取方法
+  getConfig() {
+    return this.config;
+  }
+
+  getImportantFlags() {
+    return this.importantFlags;
+  }
+
+  getCssNameMap() {
+    return this.cssNameMap;
+  }
+
+  getBaseClassNameMap() {
+    return this.baseClassNameMap;
+  }
+
+  getUserStaticClassSet() {
+    return this.userStaticClassSet;
+  }
+
+  getUserBaseClass() {
+    return this.userBaseClass;
+  }
+
+  getUserStaticClass() {
+    return this.userStaticClass;
+  }
+
+  getBaseUnit() {
+    return this.baseUnit;
+  }
+
+  getMultiFile() {
+    return this.multiFile;
+  }
+
+  /**
+   * 获取 multiFile.entry 下的所有监听/扫描入口路径（支持多目录/多文件）
+   * - 兼容：entry.path 可以是 string 或 string[]
+   * - 推荐：entry.paths: string[]
+   * @returns {string[]}
+   */
+  getMultiFileEntryPaths() {
+    const entry = this.multiFile?.entry;
+    const pathsValue = entry?.paths ?? entry?.path;
+
+    if (Array.isArray(pathsValue)) {
+      return pathsValue.filter((p) => typeof p === 'string' && p.trim()).map((p) => p.trim());
+    }
+    if (typeof pathsValue === 'string' && pathsValue.trim()) {
+      return [pathsValue.trim()];
+    }
+    return [];
+  }
+
+  getUnitConversion() {
+    return Number(this.config.system?.unitConversion || this.config.unitConversion) || 1;
+  }
+
+  getCompression() {
+    return this.config.system?.compression || this.config.compression || false;
+  }
+
+  getCssFormat() {
+    // 获取CSS格式配置，默认返回 'multiLine'
+    return this.config.system?.cssFormat || 'multiLine';
+  }
+
+  getSortClasses() {
+    // 获取排序配置，默认返回 false
+    return this.config.system?.sortClasses || false;
+  }
+
+  getBreakpoints() {
+    // 获取响应式断点配置
+    return this.breakpoints || {};
+  }
+
+  getVariants() {
+    // 获取变体配置（responsive, states, darkMode 等）
+    return this.config.variants || {};
+  }
+
+  getOutput() {
+    return this.config.output;
+  }
+
+  // 设置依赖（FileUtils和Logger）
+  setDependencies(fileUtils, logger) {
+    this._fileUtils = fileUtils;
+    this._logger = logger;
+  }
+
+  // 获取共用CSS文件路径
+  getCommonCssPath() {
+    // 优先从 multiFile.output.commonCssPath 读取
+    let commonCssPath = this.multiFile?.output?.commonCssPath;
+    
+    // 如果没有，尝试从 output.commonCssPath 读取（向后兼容）
+    if (!commonCssPath && this.config?.output?.commonCssPath) {
+      commonCssPath = this.config.output.commonCssPath;
+    }
+    
+    return commonCssPath || null;
+  }
+
+  // 读取共用CSS文件内容
+  async getCommonCssContent() {
+    // 检查依赖是否已设置
+    if (!this._fileUtils || !this._logger) {
+      return '';
+    }
+
+    // 获取共用CSS文件路径
+    const commonCssPath = this.getCommonCssPath();
+    if (!commonCssPath) {
+      return '';
+    }
+
+    // 如果缓存存在，直接返回
+    if (this._commonCssCache !== null) {
+      return this._commonCssCache;
+    }
+
+    try {
+      // 解析路径：支持绝对路径和相对路径
+      // 如果是绝对路径，直接使用；如果是相对路径，基于配置文件所在目录解析
+      let absolutePath;
+      if (path.isAbsolute(commonCssPath)) {
+        // 绝对路径：直接使用并规范化
+        absolutePath = path.normalize(commonCssPath);
+      } else {
+        // 相对路径：基于配置文件所在目录解析
+        const configDir = path.dirname(this.configPath);
+        absolutePath = path.resolve(configDir, commonCssPath);
+      }
+
+      // 检查文件是否存在
+      const exists = await this._fileUtils.fileExists(absolutePath);
+      if (!exists) {
+        this._logger.warn(`共用CSS文件不存在: ${absolutePath}`);
+        this._commonCssCache = '';
+        return '';
+      }
+
+      // 读取文件内容
+      const content = await this._fileUtils.readFile(absolutePath, 'utf-8');
+      if (content === null) {
+        this._logger.warn(`读取共用CSS文件失败: ${absolutePath}`);
+        this._commonCssCache = '';
+        return '';
+      }
+
+      // 缓存内容
+      this._commonCssCache = content;
+      this._logger.info(`成功读取共用CSS文件: ${absolutePath} (${content.length} 字符)`);
+      return content;
+    } catch (error) {
+      this._logger.warn(`读取共用CSS文件时出错: ${commonCssPath}`, error.message);
+      this._commonCssCache = '';
+      return '';
+    }
+  }
+
+  // 配置验证
+  validateConfig() {
+    const errors = [];
+
+    if (!this.config) {
+      errors.push('Configuration is null or undefined');
+      return errors;
+    }
+
+    // 检查系统配置
+    if (!this.config.system?.baseUnit && !this.config.baseUnit) {
+      errors.push('baseUnit configuration is required (either in system.baseUnit or baseUnit)');
+    }
+
+    // 检查原子规则配置
+    const atomicRules = this.config.atomicRules;
+    const baseClassName = this.config.baseClassName;
+
+    if (!atomicRules || typeof atomicRules !== 'object') {
+      errors.push('atomicRules configuration is required and must be an object');
+    }
+
+    if (!baseClassName || typeof baseClassName !== 'object') {
+      errors.push('baseClassName configuration is required and must be an object');
+    }
+
+    if (this.config.multiFile) {
+      const entry = this.config.multiFile.entry;
+      const pathsValue = entry?.paths ?? entry?.path;
+      const hasValidString = typeof pathsValue === 'string' && pathsValue.trim().length > 0;
+      const hasValidArray =
+        Array.isArray(pathsValue) &&
+        pathsValue.some((p) => typeof p === 'string' && p.trim().length > 0);
+
+      if (!hasValidString && !hasValidArray) {
+        errors.push('multiFile.entry.path (string|string[]) or multiFile.entry.paths (string[]) is required when multiFile is enabled');
+      }
+    }
+
+    if (this.config.output) {
+      if (!this.config.output.path || !this.config.output.fileName) {
+        errors.push('output.path and output.fileName are required');
+      }
+    }
+
+    return errors;
+  }
+
+  // 配置重载
+  async reloadConfig() {
+    try {
+      this.eventBus.emit('config:reloading');
+      this.loadConfig();
+      this.eventBus.emit('config:reloaded', this.config);
+      return true;
+    } catch (error) {
+      this.eventBus.emit('config:reload:error', error);
+      return false;
+    }
+  }
+
+  // 配置信息输出
+  getConfigInfo() {
+    return {
+      userBaseClassCount: this.userBaseClass.length,
+      userStaticClassCount: this.userStaticClass.length,
+      importantFlags: this.importantFlags,
+      baseUnit: this.baseUnit,
+      multiFile: !!this.multiFile,
+      compression: this.getCompression(),
+      unitConversion: this.getUnitConversion(),
+    };
+  }
+
+  // 运行时覆盖配置
+  overrideConfig(overrides) {
+    if (!overrides || typeof overrides !== 'object') {
+      return;
+    }
+
+    // 确保 config 对象存在
+    if (!this.config) {
+      this.config = {};
+    }
+
+    // 覆盖输入目录（multiFile.entry.path）
+    if (overrides.inputPath) {
+      if (!this.config.multiFile) {
+        this.config.multiFile = {};
+      }
+      if (!this.config.multiFile.entry) {
+        this.config.multiFile.entry = {};
+      }
+      this.config.multiFile.entry.path = overrides.inputPath;
+      this.eventBus.emit('config:override:inputPath', overrides.inputPath);
+    }
+
+    // 覆盖输出目录（multiFile.output.path）
+    if (overrides.outputPath) {
+      if (!this.config.multiFile) {
+        this.config.multiFile = {};
+      }
+      if (!this.config.multiFile.output) {
+        this.config.multiFile.output = {};
+      }
+      this.config.multiFile.output.path = overrides.outputPath;
+      this.eventBus.emit('config:override:outputPath', overrides.outputPath);
+    }
+
+    // 覆盖输出文件名（multiFile.output.fileName）
+    if (overrides.outputFileName) {
+      if (!this.config.multiFile) {
+        this.config.multiFile = {};
+      }
+      if (!this.config.multiFile.output) {
+        this.config.multiFile.output = {};
+      }
+      this.config.multiFile.output.fileName = overrides.outputFileName;
+      this.eventBus.emit('config:override:outputFileName', overrides.outputFileName);
+    }
+
+    // 覆盖输出类型（multiFile.output.cssOutType）
+    if (overrides.outputType) {
+      if (!this.config.multiFile) {
+        this.config.multiFile = {};
+      }
+      if (!this.config.multiFile.output) {
+        this.config.multiFile.output = {};
+      }
+      this.config.multiFile.output.cssOutType = overrides.outputType;
+      this.eventBus.emit('config:override:outputType', overrides.outputType);
+    }
+
+    // 重新更新配置引用
+    this.updateConfigReferences();
+    this.eventBus.emit('config:overridden', overrides);
+  }
+}
+
+module.exports = ConfigManager;