css2class 2.0.0

package/src/utils/CssFormatter.js

@@ -0,0 +1,261 @@
+class CssFormatter {
+  constructor(format = 'multiLine') {
+    this.format = format;
+  }
+
+  // 转义 CSS 选择器中的特殊字符
+  // 确保生成的 CSS 选择器能正确匹配 HTML/WXML 中的 class 名
+  escapeSelector(selector) {
+    if (!selector || typeof selector !== 'string') {
+      return selector;
+    }
+
+    // 转义特殊字符：冒号、感叹号、空格、斜杠等
+    // CSS 选择器中需要转义的字符：: ! / \ 空格等
+    // 使用反斜杠转义，例如 sm:w-100 -> sm\:w-100
+    return selector.replace(/([:!\/\\\s])/g, '\\$1');
+  }
+
+  // 设置格式
+  setFormat(format) {
+    if (['multiLine', 'singleLine', 'compressed'].includes(format)) {
+      this.format = format;
+    } else {
+      this.format = 'multiLine'; // 默认格式
+    }
+  }
+
+  // 获取当前格式
+  getFormat() {
+    return this.format;
+  }
+
+  // 格式化单个CSS规则
+  formatRule(selector, properties, format = null) {
+    const targetFormat = format || this.format;
+
+    if (targetFormat === 'compressed') {
+      return this.formatRuleCompressed(selector, properties);
+    } else if (targetFormat === 'singleLine') {
+      return this.formatRuleSingleLine(selector, properties);
+    } else {
+      return this.formatRuleMultiLine(selector, properties);
+    }
+  }
+
+  // 多行格式（默认）
+  formatRuleMultiLine(selector, properties) {
+    // 转义选择器中的特殊字符
+    const escapedSelector = this.escapeSelector(selector);
+    
+    if (Array.isArray(properties)) {
+      // 属性数组格式：[{property: 'margin', value: '10rpx'}, ...]
+      let css = `\n.${escapedSelector} {\n`;
+      properties.forEach(({ property, value }) => {
+        css += `  ${property}: ${value};\n`;
+      });
+      css += `}\n`;
+      return css;
+    } else if (typeof properties === 'string') {
+      // 字符串格式：'margin: 10rpx;'
+      return `\n.${escapedSelector} {\n  ${properties}\n}\n`;
+    }
+    return '';
+  }
+
+  // 单行格式
+  formatRuleSingleLine(selector, properties) {
+    // 转义选择器中的特殊字符
+    const escapedSelector = this.escapeSelector(selector);
+    
+    if (Array.isArray(properties)) {
+      // 属性数组格式
+      const propsStr = properties.map(({ property, value }) => `${property}: ${value}`).join('; ');
+      return `.${escapedSelector} { ${propsStr}; }\n`;
+    } else if (typeof properties === 'string') {
+      // 字符串格式
+      return `.${escapedSelector} { ${properties}; }\n`;
+    }
+    return '';
+  }
+
+  // 压缩格式
+  formatRuleCompressed(selector, properties) {
+    // 转义选择器中的特殊字符
+    const escapedSelector = this.escapeSelector(selector);
+    
+    if (Array.isArray(properties)) {
+      // 属性数组格式
+      const propsStr = properties.map(({ property, value }) => `${property}:${value}`).join(';');
+      return `.${escapedSelector}{${propsStr}}`;
+    } else if (typeof properties === 'string') {
+      // 字符串格式，移除空格但保留分号（除了最后一个分号）
+      let cleanProps = properties.replace(/\s+/g, ''); // 移除所有空格
+      // 确保属性之间有分号分隔，但移除末尾的分号
+      cleanProps = cleanProps.replace(/;+$/, ''); // 移除末尾的分号
+      // 确保分号后面没有空格（虽然已经移除了空格，但为了安全）
+      cleanProps = cleanProps.replace(/;+/g, ';'); // 多个分号合并为一个
+      return `.${escapedSelector}{${cleanProps}}`;
+    }
+    return '';
+  }
+
+  // 格式化完整CSS字符串
+  formatCSS(cssString, format = null) {
+    if (!cssString || typeof cssString !== 'string') {
+      return '';
+    }
+
+    const targetFormat = format || this.format;
+
+    if (targetFormat === 'compressed') {
+      return this.compressCSS(cssString);
+    } else if (targetFormat === 'singleLine') {
+      return this.singleLineCSS(cssString);
+    } else {
+      return this.multiLineCSS(cssString);
+    }
+  }
+
+  // 压缩CSS（去除所有空格、换行、注释）
+  compressCSS(cssString) {
+    return cssString
+      .replace(/\/\*[\s\S]*?\*\//g, '') // 移除注释
+      .replace(/\s+/g, ' ') // 多个空格合并为一个
+      .replace(/\s*{\s*/g, '{') // 移除大括号周围的空格
+      .replace(/\s*}\s*/g, '}') // 移除大括号周围的空格
+      .replace(/\s*:\s*/g, ':') // 移除冒号周围的空格
+      .replace(/\s*;\s*/g, ';') // 移除分号周围的空格（保留分号）
+      .replace(/\s*,\s*/g, ',') // 移除逗号周围的空格
+      .replace(/;\s*}/g, '}') // 移除结束大括号前的分号（CSS规则结束不需要分号）
+      .replace(/\s+/g, '') // 移除所有剩余空格
+      .trim();
+  }
+
+  // 单行CSS（每个规则单行，但规则之间换行）
+  singleLineCSS(cssString) {
+    // 先压缩，然后按规则分割，每行一个规则
+    const compressed = this.compressCSS(cssString);
+    // 按 } 分割规则
+    const rules = compressed.split('}').filter(rule => rule.trim());
+    return rules.map(rule => rule.trim() + '}').join('\n') + '\n';
+  }
+
+  // 多行CSS（格式化，保持可读性）
+  multiLineCSS(cssString) {
+    // 如果已经是多行格式，直接返回
+    if (cssString.includes('\n')) {
+      return cssString;
+    }
+
+    // 将压缩的CSS转换为多行格式
+    let formatted = cssString
+      .replace(/\{/g, ' {\n  ')
+      .replace(/;/g, ';\n  ')
+      .replace(/\}/g, '\n}\n')
+      .replace(/\n\s*\n/g, '\n'); // 移除多余空行
+
+    // 清理格式
+    formatted = formatted
+      .split('\n')
+      .map(line => line.trim())
+      .filter(line => line.length > 0)
+      .map((line, index, array) => {
+        if (line.endsWith('{')) {
+          return line;
+        } else if (line === '}') {
+          return line;
+        } else if (line.endsWith(';')) {
+          return '  ' + line;
+        }
+        return '  ' + line;
+      })
+      .join('\n') + '\n';
+
+    return formatted;
+  }
+
+  // 格式化属性值对数组为字符串
+  formatProperties(properties, format = null) {
+    const targetFormat = format || this.format;
+
+    if (Array.isArray(properties)) {
+      if (targetFormat === 'compressed') {
+        return properties.map(({ property, value }) => `${property}:${value}`).join(';');
+      } else if (targetFormat === 'singleLine') {
+        return properties.map(({ property, value }) => `${property}: ${value}`).join('; ');
+      } else {
+        return properties.map(({ property, value }) => `  ${property}: ${value};\n`).join('');
+      }
+    }
+    return '';
+  }
+
+  // 对CSS规则进行字母排序
+  sortCSSRules(cssString) {
+    if (!cssString || typeof cssString !== 'string') {
+      return '';
+    }
+
+    // 解析CSS规则：逐字符解析，跟踪大括号嵌套
+    const rules = [];
+    let currentRule = '';
+    let braceCount = 0;
+    let selector = '';
+    let i = 0;
+
+    while (i < cssString.length) {
+      const char = cssString[i];
+
+      if (char === '{') {
+        if (braceCount === 0) {
+          // 找到选择器结束
+          selector = currentRule.trim();
+          currentRule = '{';
+        } else {
+          currentRule += char;
+        }
+        braceCount++;
+      } else if (char === '}') {
+        currentRule += char;
+        braceCount--;
+        if (braceCount === 0) {
+          // 找到规则结束
+          // 清理选择器：移除点号前缀用于排序（注意：转义字符不需要处理，排序时保持原样）
+          const cleanSelector = selector.replace(/^\./, '').trim();
+          if (cleanSelector) {
+            rules.push({
+              selector: cleanSelector,
+              fullRule: selector + currentRule,
+            });
+          }
+          currentRule = '';
+          selector = '';
+        }
+      } else {
+        currentRule += char;
+      }
+      i++;
+    }
+
+    // 如果没有匹配到规则，返回原字符串
+    if (rules.length === 0) {
+      return cssString;
+    }
+
+    // 按选择器名称进行字母排序（不区分大小写）
+    rules.sort((a, b) => {
+      const selectorA = a.selector.toLowerCase();
+      const selectorB = b.selector.toLowerCase();
+      if (selectorA < selectorB) return -1;
+      if (selectorA > selectorB) return 1;
+      return 0;
+    });
+
+    // 重新组合CSS规则
+    return rules.map(rule => rule.fullRule).join('');
+  }
+}
+
+module.exports = CssFormatter;
+

package/src/utils/FileUtils.js

@@ -0,0 +1,230 @@
+const path = require('path');
+const fs = require('fs').promises;
+
+class FileUtils {
+  constructor(eventBus) {
+    this.eventBus = eventBus;
+  }
+
+  // 文件信息提取
+  getFileInfo(filePath) {
+    try {
+      const fileName = path.basename(filePath);
+      const fileType = path.extname(filePath).substring(1);
+      const fileDir = path.dirname(filePath);
+      const fileTName = path.basename(filePath, path.extname(filePath));
+
+      return {
+        fileName,
+        fileType,
+        filePath: fileDir,
+        fileTName,
+        path: filePath,
+        fullPath: path.resolve(filePath),
+      };
+    } catch (error) {
+      this.eventBus.emit('fileUtils:error', { operation: 'getFileInfo', filePath, error });
+      return null;
+    }
+  }
+
+  // 路径标准化
+  normalizePath(filePath) {
+    return filePath.replace(/\\/g, '/');
+  }
+
+  // 路径合并
+  joinPaths(...paths) {
+    return path.join(...paths).replace(/\\/g, '/');
+  }
+
+  // 文件存在检查
+  async fileExists(filePath) {
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // 目录存在检查
+  async directoryExists(dirPath) {
+    try {
+      const stat = await fs.stat(dirPath);
+      return stat.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  // 创建目录
+  async createDirectory(dirPath) {
+    try {
+      await fs.mkdir(dirPath, { recursive: true });
+      this.eventBus.emit('fileUtils:directory:created', dirPath);
+      return true;
+    } catch (error) {
+      this.eventBus.emit('fileUtils:error', { operation: 'createDirectory', dirPath, error });
+      return false;
+    }
+  }
+
+  // 读取文件
+  async readFile(filePath, encoding = 'utf-8') {
+    try {
+      const content = await fs.readFile(filePath, encoding);
+      this.eventBus.emit('fileUtils:file:read', filePath);
+      return content;
+    } catch (error) {
+      this.eventBus.emit('fileUtils:error', { operation: 'readFile', filePath, error });
+      return null;
+    }
+  }
+
+  // 写入文件
+  async writeFile(filePath, content, encoding = 'utf-8') {
+    try {
+      // 确保目录存在
+      const dirPath = path.dirname(filePath);
+      await this.createDirectory(dirPath);
+
+      await fs.writeFile(filePath, content, encoding);
+      this.eventBus.emit('fileUtils:file:written', filePath);
+      return true;
+    } catch (error) {
+      this.eventBus.emit('fileUtils:error', { operation: 'writeFile', filePath, error });
+      return false;
+    }
+  }
+
+  // 获取文件统计信息
+  async getFileStats(filePath) {
+    try {
+      const stats = await fs.stat(filePath);
+      return {
+        size: stats.size,
+        mtime: stats.mtime,
+        ctime: stats.ctime,
+        isFile: stats.isFile(),
+        isDirectory: stats.isDirectory(),
+      };
+    } catch (error) {
+      this.eventBus.emit('fileUtils:error', { operation: 'getFileStats', filePath, error });
+      return null;
+    }
+  }
+
+  // 文件类型检查
+  isHtmlFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return ['.html', '.htm'].includes(ext);
+  }
+
+  isWxmlFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return ext === '.wxml';
+  }
+
+  isSupportedFile(filePath, supportedTypes = ['html', 'wxml']) {
+    const ext = path.extname(filePath).toLowerCase().substring(1);
+    return supportedTypes.includes(ext);
+  }
+
+  // 路径模式匹配
+  matchPathPattern(filePath, patterns) {
+    const normalizedPath = this.normalizePath(filePath);
+
+    return patterns.some((pattern) => {
+      // 简单的通配符匹配
+      const regexPattern = pattern.replace(/\\/g, '/').replace(/\*/g, '.*').replace(/\?/g, '.');
+
+      const regex = new RegExp(`^${regexPattern}$`);
+      return regex.test(normalizedPath);
+    });
+  }
+
+  // 相对路径计算
+  getRelativePath(fromPath, toPath) {
+    try {
+      return path.relative(fromPath, toPath).replace(/\\/g, '/');
+    } catch (error) {
+      this.eventBus.emit('fileUtils:error', {
+        operation: 'getRelativePath',
+        fromPath,
+        toPath,
+        error,
+      });
+      return toPath;
+    }
+  }
+
+  // 绝对路径转换
+  getAbsolutePath(filePath, basePath = process.cwd()) {
+    try {
+      return path.resolve(basePath, filePath).replace(/\\/g, '/');
+    } catch (error) {
+      this.eventBus.emit('fileUtils:error', {
+        operation: 'getAbsolutePath',
+        filePath,
+        basePath,
+        error,
+      });
+      return filePath;
+    }
+  }
+
+  // 文件扩展名处理
+  changeExtension(filePath, newExt) {
+    const ext = path.extname(filePath);
+    const basePath = filePath.substring(0, filePath.length - ext.length);
+    return `${basePath}${newExt.startsWith('.') ? newExt : `.${newExt}`}`;
+  }
+
+  // 批量文件操作
+  async batchProcess(files, processor, options = {}) {
+    const results = [];
+    const { concurrency = 5, onProgress } = options;
+
+    for (let i = 0; i < files.length; i += concurrency) {
+      const batch = files.slice(i, i + concurrency);
+      const batchPromises = batch.map(async (file) => {
+        try {
+          const result = await processor(file);
+          return { file, success: true, result };
+        } catch (error) {
+          return { file, success: false, error };
+        }
+      });
+
+      const batchResults = await Promise.all(batchPromises);
+      results.push(...batchResults);
+
+      if (onProgress) {
+        onProgress(i + batch.length, files.length);
+      }
+    }
+
+    this.eventBus.emit('fileUtils:batch:completed', { totalFiles: files.length, results });
+    return results;
+  }
+
+  // 文件监控辅助
+  getFileChangeType(oldStats, newStats) {
+    if (!oldStats || !newStats) {
+      return 'unknown';
+    }
+
+    if (oldStats.mtime.getTime() !== newStats.mtime.getTime()) {
+      return 'modified';
+    }
+
+    if (oldStats.size !== newStats.size) {
+      return 'size_changed';
+    }
+
+    return 'unchanged';
+  }
+}
+
+module.exports = FileUtils;

package/src/utils/Logger.js

@@ -0,0 +1,150 @@
+class Logger {
+  constructor(eventBus, options = {}) {
+    this.eventBus = eventBus;
+    this.level = options.level || 'info'; // debug, info, warn, error
+    this.enableTimestamp = options.enableTimestamp !== false;
+    this.enableDebug = options.enableDebug || false;
+
+    this.levels = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3,
+    };
+  }
+
+  formatMessage(level, message) {
+    const timestamp = this.enableTimestamp ? `[${new Date().toLocaleString()}]` : '';
+    const levelTag = `[${level.toUpperCase()}]`;
+    return `${timestamp} ${levelTag} ${message}`.trim();
+  }
+
+  shouldLog(level) {
+    return this.levels[level] >= this.levels[this.level];
+  }
+
+  debug(message, ...args) {
+    if (this.shouldLog('debug') && this.enableDebug) {
+      const formattedMessage = this.formatMessage('debug', message);
+      console.log(formattedMessage, ...args);
+      this.eventBus.emit('log:debug', { message, args });
+    }
+  }
+
+  info(message, ...args) {
+    if (this.shouldLog('info')) {
+      const formattedMessage = this.formatMessage('info', message);
+      console.log(formattedMessage, ...args);
+      this.eventBus.emit('log:info', { message, args });
+    }
+  }
+
+  warn(message, ...args) {
+    if (this.shouldLog('warn')) {
+      const formattedMessage = this.formatMessage('warn', message);
+      console.warn(formattedMessage, ...args);
+      this.eventBus.emit('log:warn', { message, args });
+    }
+  }
+
+  error(message, ...args) {
+    if (this.shouldLog('error')) {
+      const formattedMessage = this.formatMessage('error', message);
+      console.error(formattedMessage, ...args);
+      this.eventBus.emit('log:error', { message, args });
+    }
+  }
+
+  // 特定领域的日志方法
+  config(message, ...args) {
+    this.info(`[CONFIG] ${message}`, ...args);
+  }
+
+  cache(message, ...args) {
+    this.debug(`[CACHE] ${message}`, ...args);
+  }
+
+  parser(message, ...args) {
+    this.debug(`[PARSER] ${message}`, ...args);
+  }
+
+  generator(message, ...args) {
+    this.debug(`[GENERATOR] ${message}`, ...args);
+  }
+
+  watcher(message, ...args) {
+    this.info(`[WATCHER] ${message}`, ...args);
+  }
+
+  writer(message, ...args) {
+    this.info(`[WRITER] ${message}`, ...args);
+  }
+
+  scan(message, ...args) {
+    this.info(`[SCAN] ${message}`, ...args);
+  }
+
+  // 日志级别设置
+  setLevel(level) {
+    if (this.levels.hasOwnProperty(level)) {
+      this.level = level;
+      this.info(`Log level changed to: ${level}`);
+      this.eventBus.emit('log:level:changed', level);
+    } else {
+      this.error(`Invalid log level: ${level}`);
+    }
+  }
+
+  getLevel() {
+    return this.level;
+  }
+
+  // 调试模式切换
+  setDebugMode(enabled) {
+    this.enableDebug = enabled;
+    this.info(`Debug mode ${enabled ? 'enabled' : 'disabled'}`);
+    this.eventBus.emit('log:debug:changed', enabled);
+  }
+
+  // 时间戳切换
+  setTimestamp(enabled) {
+    this.enableTimestamp = enabled;
+    this.info(`Timestamp ${enabled ? 'enabled' : 'disabled'}`);
+    this.eventBus.emit('log:timestamp:changed', enabled);
+  }
+
+  // 性能日志
+  time(label) {
+    if (this.shouldLog('debug')) {
+      console.time(`[PERF] ${label}`);
+      this.eventBus.emit('log:time:start', label);
+    }
+  }
+
+  timeEnd(label) {
+    if (this.shouldLog('debug')) {
+      console.timeEnd(`[PERF] ${label}`);
+      this.eventBus.emit('log:time:end', label);
+    }
+  }
+
+  // 统计信息日志
+  stats(stats) {
+    this.info('[STATS]', stats);
+    this.eventBus.emit('log:stats', stats);
+  }
+
+  // 错误日志增强
+  errorWithContext(message, error, context = {}) {
+    this.error(message);
+    if (error && error.stack) {
+      this.error('Stack trace:', error.stack);
+    }
+    if (Object.keys(context).length > 0) {
+      this.error('Context:', context);
+    }
+    this.eventBus.emit('log:error:withContext', { message, error, context });
+  }
+}
+
+module.exports = Logger;