css2class 2.0.0

package/src/parsers/ImportantParser.js

@@ -0,0 +1,279 @@
+class ImportantParser {
+  constructor(eventBus, importantFlags) {
+    this.eventBus = eventBus;
+    this.importantFlags = importantFlags;
+  }
+
+  // 检测类名是否包含Important标识
+  hasImportantFlag(className) {
+    if (!className || typeof className !== 'string') {
+      return false;
+    }
+
+    // 检查前缀标识
+    for (const prefix of this.importantFlags.prefix) {
+      if (className.startsWith(prefix)) {
+        this.eventBus.emit('important:detected', { className, type: 'prefix', flag: prefix });
+        return true;
+      }
+    }
+
+    // 检查后缀标识
+    for (const suffix of this.importantFlags.suffix) {
+      if (className.endsWith(suffix)) {
+        this.eventBus.emit('important:detected', { className, type: 'suffix', flag: suffix });
+        return true;
+      }
+    }
+
+    // 检查自定义标识
+    for (const custom of this.importantFlags.custom) {
+      if (className.includes(custom)) {
+        this.eventBus.emit('important:detected', { className, type: 'custom', flag: custom });
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  // 清理Important标识，返回干净的类名
+  cleanImportantFlag(className) {
+    if (!className || typeof className !== 'string') {
+      return className;
+    }
+
+    let cleanName = className;
+    let removedFlag = null;
+    let removedType = null;
+
+    // 清理前缀标识
+    for (const prefix of this.importantFlags.prefix) {
+      if (cleanName.startsWith(prefix)) {
+        cleanName = cleanName.substring(prefix.length);
+        removedFlag = prefix;
+        removedType = 'prefix';
+        break;
+      }
+    }
+
+    // 清理后缀标识
+    if (!removedFlag) {
+      for (const suffix of this.importantFlags.suffix) {
+        if (cleanName.endsWith(suffix)) {
+          cleanName = cleanName.substring(0, cleanName.length - suffix.length);
+          removedFlag = suffix;
+          removedType = 'suffix';
+          break;
+        }
+      }
+    }
+
+    // 清理自定义标识
+    if (!removedFlag) {
+      for (const custom of this.importantFlags.custom) {
+        if (cleanName.includes(custom)) {
+          cleanName = cleanName.replace(custom, '');
+          removedFlag = custom;
+          removedType = 'custom';
+          break;
+        }
+      }
+    }
+
+    if (removedFlag) {
+      this.eventBus.emit('important:cleaned', {
+        original: className,
+        cleaned: cleanName,
+        removedFlag,
+        removedType,
+      });
+    }
+
+    return cleanName;
+  }
+
+  // 为CSS值添加!important
+  addImportantToCss(cssValue, isImportant) {
+    if (!isImportant) {
+      return cssValue;
+    }
+
+    // 如果已经包含!important，直接返回
+    if (cssValue.includes('!important')) {
+      return cssValue;
+    }
+
+    // 清理末尾的分号和空格
+    const cleanValue = cssValue.replace(/;?\s*$/, '');
+    const result = `${cleanValue} !important;`;
+
+    this.eventBus.emit('important:added', { original: cssValue, result });
+    return result;
+  }
+
+  // 批量处理Important标识
+  batchProcessImportant(classNames) {
+    const results = [];
+
+    for (const className of classNames) {
+      const isImportant = this.hasImportantFlag(className);
+      const cleanName = this.cleanImportantFlag(className);
+
+      results.push({
+        original: className,
+        clean: cleanName,
+        isImportant,
+        hasImportantFlag: isImportant,
+      });
+    }
+
+    this.eventBus.emit('important:batch:processed', {
+      totalCount: classNames.length,
+      importantCount: results.filter((r) => r.isImportant).length,
+    });
+
+    return results;
+  }
+
+  // 验证Important标识配置
+  validateImportantFlags() {
+    const errors = [];
+    const warnings = [];
+
+    // 检查前缀标识
+    if (!Array.isArray(this.importantFlags.prefix)) {
+      errors.push('importantFlags.prefix must be an array');
+    } else {
+      this.importantFlags.prefix.forEach((flag, index) => {
+        if (typeof flag !== 'string' || flag.length === 0) {
+          errors.push(`importantFlags.prefix[${index}] must be a non-empty string`);
+        }
+      });
+    }
+
+    // 检查后缀标识
+    if (!Array.isArray(this.importantFlags.suffix)) {
+      errors.push('importantFlags.suffix must be an array');
+    } else {
+      this.importantFlags.suffix.forEach((flag, index) => {
+        if (typeof flag !== 'string' || flag.length === 0) {
+          errors.push(`importantFlags.suffix[${index}] must be a non-empty string`);
+        }
+      });
+    }
+
+    // 检查自定义标识
+    if (!Array.isArray(this.importantFlags.custom)) {
+      errors.push('importantFlags.custom must be an array');
+    } else {
+      this.importantFlags.custom.forEach((flag, index) => {
+        if (typeof flag !== 'string' || flag.length === 0) {
+          errors.push(`importantFlags.custom[${index}] must be a non-empty string`);
+        }
+      });
+    }
+
+    // 检查标识冲突
+    const allFlags = [
+      ...this.importantFlags.prefix,
+      ...this.importantFlags.suffix,
+      ...this.importantFlags.custom,
+    ];
+
+    const duplicates = allFlags.filter((flag, index) => allFlags.indexOf(flag) !== index);
+    if (duplicates.length > 0) {
+      warnings.push(`Duplicate important flags detected: ${duplicates.join(', ')}`);
+    }
+
+    return { errors, warnings, isValid: errors.length === 0 };
+  }
+
+  // 获取Important标识统计
+  getImportantStats() {
+    return {
+      prefixCount: this.importantFlags.prefix.length,
+      suffixCount: this.importantFlags.suffix.length,
+      customCount: this.importantFlags.custom.length,
+      totalFlags:
+        this.importantFlags.prefix.length +
+        this.importantFlags.suffix.length +
+        this.importantFlags.custom.length,
+      flags: {
+        prefix: [...this.importantFlags.prefix],
+        suffix: [...this.importantFlags.suffix],
+        custom: [...this.importantFlags.custom],
+      },
+    };
+  }
+
+  // 更新Important标识配置
+  updateImportantFlags(newImportantFlags) {
+    const oldFlags = { ...this.importantFlags };
+    this.importantFlags = newImportantFlags;
+
+    this.eventBus.emit('important:flags:updated', {
+      old: oldFlags,
+      new: newImportantFlags,
+    });
+  }
+
+  // 测试Important标识
+  testImportantFlags(testClassNames) {
+    const results = [];
+
+    for (const className of testClassNames) {
+      const isImportant = this.hasImportantFlag(className);
+      const cleanName = this.cleanImportantFlag(className);
+
+      results.push({
+        className,
+        isImportant,
+        cleanName,
+        originalLength: className.length,
+        cleanLength: cleanName.length,
+      });
+    }
+
+    return results;
+  }
+
+  // 生成Important标识示例
+  generateExamples() {
+    const examples = [];
+
+    // 前缀示例
+    this.importantFlags.prefix.forEach((prefix) => {
+      examples.push({
+        type: 'prefix',
+        flag: prefix,
+        example: `${prefix}w-100`,
+        description: `Class with prefix flag "${prefix}"`,
+      });
+    });
+
+    // 后缀示例
+    this.importantFlags.suffix.forEach((suffix) => {
+      examples.push({
+        type: 'suffix',
+        flag: suffix,
+        example: `w-100${suffix}`,
+        description: `Class with suffix flag "${suffix}"`,
+      });
+    });
+
+    // 自定义示例
+    this.importantFlags.custom.forEach((custom) => {
+      examples.push({
+        type: 'custom',
+        flag: custom,
+        example: `w-100${custom}`,
+        description: `Class with custom flag "${custom}"`,
+      });
+    });
+
+    return examples;
+  }
+}
+
+module.exports = ImportantParser;

package/src/parsers/RegexCompiler.js

@@ -0,0 +1,200 @@
+class RegexCompiler {
+  constructor(eventBus, importantFlags) {
+    this.eventBus = eventBus;
+    this.importantFlags = importantFlags;
+    this.compiledRegex = null;
+    this.cache = new Map();
+
+    this.compileRegex();
+  }
+
+  escapeRegex(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+
+  compileRegex() {
+    try {
+      const allFlags = [
+        ...this.importantFlags.prefix.map((flag) => `^${this.escapeRegex(flag)}`),
+        ...this.importantFlags.suffix.map((flag) => `${this.escapeRegex(flag)}$`),
+        ...this.importantFlags.custom.map((flag) => this.escapeRegex(flag)),
+      ];
+
+      this.compiledRegex = {
+        classAttr: /class=(\"[^\"]*\"|'[^']*')/g,
+        classNames: /[\w\-!]+/g,
+        importantFlag: new RegExp(allFlags.join('|')),
+        twoPartClass: /^([a-zA-Z_]+)-(.+)$/,
+        percentageValue: /(\d+)b$/,
+        whitespace: /\s+/g,
+        quotes: /^["']|["']$/g,
+      };
+
+      this.eventBus.emit('regex:compiled', this.compiledRegex);
+      this.eventBus.emit('parser:regex:ready');
+    } catch (error) {
+      this.eventBus.emit('regex:compilation:error', error);
+      throw error;
+    }
+  }
+
+  // 获取编译后的正则表达式
+  getCompiledRegex() {
+    return this.compiledRegex;
+  }
+
+  // 更新Important标识并重新编译
+  updateImportantFlags(importantFlags) {
+    this.importantFlags = importantFlags;
+    this.compileRegex();
+    this.clearCache();
+  }
+
+  // 缓存管理
+  getCachedRegex(key) {
+    return this.cache.get(key);
+  }
+
+  setCachedRegex(key, regex) {
+    this.cache.set(key, regex);
+  }
+
+  clearCache() {
+    this.cache.clear();
+    this.eventBus.emit('regex:cache:cleared');
+  }
+
+  // 正则表达式测试工具
+  testClassAttribute(text) {
+    if (!this.compiledRegex.classAttr) return false;
+
+    const testRegex = new RegExp(
+      this.compiledRegex.classAttr.source,
+      this.compiledRegex.classAttr.flags
+    );
+    return testRegex.test(text);
+  }
+
+  testImportantFlag(className) {
+    if (!this.compiledRegex.importantFlag) return false;
+
+    return this.compiledRegex.importantFlag.test(className);
+  }
+
+  testTwoPartClass(className) {
+    if (!this.compiledRegex.twoPartClass) return false;
+
+    return this.compiledRegex.twoPartClass.test(className);
+  }
+
+  // 正则表达式匹配工具
+  matchClassAttributes(htmlStr) {
+    if (!this.compiledRegex.classAttr) return [];
+
+    const matches = [];
+    let match;
+    const regex = new RegExp(
+      this.compiledRegex.classAttr.source,
+      this.compiledRegex.classAttr.flags
+    );
+
+    while ((match = regex.exec(htmlStr)) !== null) {
+      matches.push({
+        fullMatch: match[0],
+        classContent: match[1],
+        index: match.index,
+      });
+    }
+
+    return matches;
+  }
+
+  matchClassNames(classStr) {
+    if (!this.compiledRegex.classNames) return [];
+
+    const matches = [];
+    let match;
+    const regex = new RegExp(
+      this.compiledRegex.classNames.source,
+      this.compiledRegex.classNames.flags
+    );
+
+    while ((match = regex.exec(classStr)) !== null) {
+      matches.push({
+        className: match[0],
+        index: match.index,
+      });
+    }
+
+    return matches;
+  }
+
+  // 性能优化：预编译常用正则
+  precompileCommonPatterns() {
+    const commonPatterns = {
+      // 常见的CSS类名模式
+      cssClass: /^[a-zA-Z_][\w\-]*$/,
+      // 数值模式
+      number: /^\d+(\.\d+)?$/,
+      // 单位模式
+      unit: /^(px|em|rem|%|vw|vh|pt|cm|mm|in)$/,
+      // 颜色模式
+      color:
+        /^(#[0-9a-fA-F]{3,6}|rgb\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*\)|rgba\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*,\s*[\d.]+\s*\))$/,
+      // 媒体查询
+      mediaQuery: /^@media\s+[^{]+$/,
+      // 选择器
+     selector: /^[.#]?[\w\-]+(\.[\w\-]+)*(\[[^\]]+\])?(:[^\s]+)*$/,
+    };
+
+    Object.entries(commonPatterns).forEach(([key, pattern]) => {
+      this.setCachedRegex(key, pattern);
+    });
+
+    this.eventBus.emit('regex:common:precompiled', Object.keys(commonPatterns));
+  }
+
+  // 正则表达式验证
+  validateRegex(pattern, flags = '') {
+    try {
+      new RegExp(pattern, flags);
+      return { valid: true };
+    } catch (error) {
+      return { valid: false, error: error.message };
+    }
+  }
+
+  // 正则表达式统计
+  getRegexStats() {
+    return {
+      compiledCount: Object.keys(this.compiledRegex || {}).length,
+      cacheSize: this.cache.size,
+      importantFlagsCount: {
+        prefix: this.importantFlags.prefix.length,
+        suffix: this.importantFlags.suffix.length,
+        custom: this.importantFlags.custom.length,
+      },
+    };
+  }
+
+  // 调试工具
+  debugRegex(pattern, testString) {
+    const validation = this.validateRegex(pattern);
+    if (!validation.valid) {
+      return { error: validation.error };
+    }
+
+    const regex = new RegExp(pattern);
+    const matches = testString.match(regex);
+
+    return {
+      pattern,
+      testString,
+      matches,
+      matchCount: matches ? matches.length : 0,
+      isValid: validation.valid,
+    };
+  }
+}
+
+module.exports = RegexCompiler;