v-auto-color 1.0.5 → 1.0.6

package/README.md

@@ -81,6 +81,8 @@ interface ColorConfig {
   hue?: [number, number];  // 色相范围，默认 [0, 360]
   saturation?: [number, number];  // 饱和度范围，默认 [70, 100]
   lightness?: [number, number];  // 亮度范围，默认 [40, 60]
+  algorithm?: 'hash' | 'levenshtein' | 'cosine' | 'jaccard';  // 算法类型，默认 'hash'
+  similarityThreshold?: number;  // 相似度阈值，默认 0.7
 }
 
 // 两种使用方式
@@ -88,6 +90,48 @@ const colorSet1 = useAutoColor('category'); // 使用字符串作为类别
 const colorSet2 = useAutoColor({ /* 完整配置 */ }); // 使用对象配置
 ```
 
+### 算法说明
+
+| 算法 | 描述 | 适用场景 |
+|------|------|----------|
+| `hash` | 基于文本哈希值生成颜色，相同文本返回相同颜色 | 快速生成，适用于文本完全匹配的场景 |
+| `levenshtein` | 基于编辑距离计算相似度，相似文本返回相似颜色 | 适用于拼写相似的文本，如 "hello" 和 "hello world" |
+| `cosine` | 基于字符频率的余弦相似度，相似文本返回相似颜色 | 适用于长度不同但字符分布相似的文本 |
+| `jaccard` | 基于字符集合的Jaccard相似度，相似文本返回相似颜色 | 适用于字符组成相似的文本 |
+
+### 算法配置示例
+
+```typescript
+import { useAutoColor } from 'v-auto-color';
+
+// 使用Levenshtein算法（编辑距离）
+const colorSet1 = useAutoColor({
+  category: 'set1',
+  algorithm: 'levenshtein',
+  similarityThreshold: 0.6 // 降低相似度阈值，使更多文本被认为相似
+});
+
+// 使用余弦相似度算法
+const colorSet2 = useAutoColor({
+  category: 'set2',
+  algorithm: 'cosine',
+  hue: [0, 180] // 限制色相范围为红色到青色
+});
+
+// 使用Jaccard相似度算法
+const colorSet3 = useAutoColor({
+  category: 'set3',
+  algorithm: 'jaccard',
+  saturation: [80, 100], // 提高饱和度，使颜色更鲜艳
+  lightness: [50, 70] // 提高亮度，使颜色更明亮
+});
+
+// 获取颜色
+const color1 = colorSet1.getColor('hello');
+const color2 = colorSet1.getColor('hello world'); // 与 'hello' 相似，返回相似颜色
+const color3 = colorSet1.getColor('test'); // 与 'hello' 不相似，返回不同颜色
+```
+
 ## 性能优化
 
 ### 编译时预计算

package/dist/chunk-754HBQKQ.mjs

@@ -0,0 +1,222 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/core/algorithms/algorithm.ts
+var DEFAULT_ALGORITHM = {
+  type: "hash"
+};
+
+// src/core/hash.ts
+function murmurHash3(text) {
+  let h1 = 3735928559;
+  const c1 = 3432918353;
+  const c2 = 461845907;
+  const r1 = 15;
+  const r2 = 13;
+  const m = 5;
+  const n = 3864292196;
+  let i = 0;
+  const length = text.length;
+  let k1 = 0;
+  while (i < length) {
+    const char = text.charCodeAt(i++);
+    k1 = k1 << 8 | char;
+  }
+  k1 = k1 * c1 >>> 0;
+  k1 = (k1 << r1 | k1 >>> 32 - r1) >>> 0;
+  k1 = k1 * c2 >>> 0;
+  h1 ^= k1;
+  h1 = (h1 << r2 | h1 >>> 32 - r2) >>> 0;
+  h1 = h1 * m + n >>> 0;
+  h1 ^= length;
+  h1 ^= h1 >>> 16;
+  h1 = h1 * 2246822507 >>> 0;
+  h1 ^= h1 >>> 13;
+  h1 = h1 * 3266489909 >>> 0;
+  h1 ^= h1 >>> 16;
+  return h1;
+}
+function getTextHash(text) {
+  return murmurHash3(text);
+}
+
+// src/core/algorithms/hashAlgorithm.ts
+var HashAlgorithm = class {
+  // Generate color from text using hash
+  generateColor(text, config) {
+    const hash = getTextHash(text);
+    const hue = config?.hue || [0, 360];
+    const saturation = config?.saturation || [70, 100];
+    const lightness = config?.lightness || [40, 60];
+    const hueRange = hue[1] - hue[0];
+    const calculatedHue = hue[0] + hash % hueRange;
+    const satRange = saturation[1] - saturation[0];
+    const calculatedSat = saturation[0] + (hash >> 8) % satRange;
+    const lightRange = lightness[1] - lightness[0];
+    const calculatedLight = lightness[0] + (hash >> 16) % lightRange;
+    return `hsl(${calculatedHue}, ${calculatedSat}%, ${calculatedLight}%)`;
+  }
+  // Get algorithm name
+  getName() {
+    return "hash";
+  }
+};
+
+// src/core/algorithms/featureAlgorithm.ts
+var FeatureAlgorithm = class {
+  // Calculate text features
+  calculateFeatures(text) {
+    const length = text.length;
+    const vowels = "aeiouAEIOU";
+    const consonants = "bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ";
+    let vowelCount = 0;
+    let consonantCount = 0;
+    const uniqueChars = /* @__PURE__ */ new Set();
+    let totalCharCode = 0;
+    for (const char of text) {
+      if (vowels.includes(char)) {
+        vowelCount++;
+      } else if (consonants.includes(char)) {
+        consonantCount++;
+      }
+      uniqueChars.add(char);
+      totalCharCode += char.charCodeAt(0);
+    }
+    return {
+      length,
+      vowelRatio: length > 0 ? vowelCount / length : 0,
+      consonantRatio: length > 0 ? consonantCount / length : 0,
+      uniqueCharRatio: length > 0 ? uniqueChars.size / length : 0,
+      avgCharCode: length > 0 ? totalCharCode / length : 0
+    };
+  }
+  // Generate color from text using features
+  generateColor(text, config) {
+    const features = this.calculateFeatures(text);
+    const hue = config?.hue || [0, 360];
+    const saturation = config?.saturation || [70, 100];
+    const lightness = config?.lightness || [40, 60];
+    const hueRange = hue[1] - hue[0];
+    const hueFactor = (features.length % 100 + features.uniqueCharRatio * 100 + features.avgCharCode % 100) / 3;
+    const calculatedHue = hue[0] + hueFactor / 100 * hueRange;
+    const satRange = saturation[1] - saturation[0];
+    const calculatedSat = saturation[0] + features.vowelRatio * satRange;
+    const lightRange = lightness[1] - lightness[0];
+    const calculatedLight = lightness[0] + features.consonantRatio * lightRange;
+    return `hsl(${calculatedHue}, ${calculatedSat}%, ${calculatedLight}%)`;
+  }
+  // Get algorithm name
+  getName() {
+    return "feature";
+  }
+};
+
+// src/core/algorithms/algorithmFactory.ts
+var AlgorithmFactory = class {
+  // Create algorithm instance based on config
+  static createAlgorithm(config = DEFAULT_ALGORITHM) {
+    switch (config.type) {
+      case "feature":
+        return new FeatureAlgorithm();
+      case "hash":
+      default:
+        return new HashAlgorithm();
+    }
+  }
+};
+
+// src/core/color.ts
+var ColorGenerator = class {
+  constructor(config = {}) {
+    __publicField(this, "config");
+    __publicField(this, "algorithm");
+    this.config = {
+      category: config.category || "default",
+      hue: config.hue || [0, 360],
+      saturation: config.saturation || [70, 100],
+      lightness: config.lightness || [40, 60],
+      algorithm: config.algorithm || DEFAULT_ALGORITHM
+    };
+    this.algorithm = AlgorithmFactory.createAlgorithm(this.config.algorithm);
+  }
+  // Get color for text
+  getColor(text) {
+    return this.algorithm.generateColor(text, this.config);
+  }
+};
+
+// src/vite-plugin.ts
+function createFilter(include, exclude) {
+  return function(id) {
+    const included = include.some((pattern) => {
+      if (pattern === "**/*") return true;
+      const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+      return regex.test(id);
+    });
+    const excluded = exclude && exclude.some((pattern) => {
+      const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+      return regex.test(id);
+    });
+    return included && !excluded;
+  };
+}
+function viteAutoColorPlugin() {
+  const filter = createFilter(["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx", "**/*.vue"]);
+  return {
+    name: "v-auto-color",
+    // Analyze code during build and inject precomputed colors
+    transform(code, id) {
+      if (!filter(id)) return null;
+      if (!code.includes("useAutoColor")) return null;
+      const useAutoColorRegex = /useAutoColor\s*\(\s*(?:(['"])([^'"]+)\1|\{[^}]*\})\s*\)/g;
+      const getColorRegex = /\.getColor\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+      let match;
+      const colorSets = /* @__PURE__ */ new Set();
+      while ((match = useAutoColorRegex.exec(code)) !== null) {
+        let category = "default";
+        if (match[2]) {
+          category = match[2];
+        } else {
+          const configMatch = match[0].match(/category\s*:\s*['"]([^'"]+)['"]/);
+          if (configMatch) {
+            category = configMatch[1];
+          }
+        }
+        colorSets.add(category);
+      }
+      const texts = /* @__PURE__ */ new Set();
+      while ((match = getColorRegex.exec(code)) !== null) {
+        texts.add(match[1]);
+      }
+      const colorUsage = {};
+      colorSets.forEach((category) => {
+        if (!colorUsage[category]) {
+          colorUsage[category] = {};
+        }
+        texts.forEach((text) => {
+          const generator = new ColorGenerator({ category });
+          const color = generator.getColor(text);
+          colorUsage[category][text] = color;
+        });
+      });
+      if (Object.keys(colorUsage).length > 0) {
+        const precomputedCode = `
+          // Precomputed colors for v-auto-color
+          import { __internal__setPrecomputedColors } from 'v-auto-color';
+          __internal__setPrecomputedColors(${JSON.stringify(colorUsage, null, 2)});
+        `;
+        code = precomputedCode + "\n" + code;
+      }
+      return code;
+    }
+  };
+}
+var vite_plugin_default = viteAutoColorPlugin;
+
+export {
+  __publicField,
+  ColorGenerator,
+  viteAutoColorPlugin,
+  vite_plugin_default
+};

package/dist/chunk-RECQIKGP.mjs

@@ -0,0 +1,144 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/core/hash.ts
+function murmurHash3(text) {
+  let h1 = 3735928559;
+  const c1 = 3432918353;
+  const c2 = 461845907;
+  const r1 = 15;
+  const r2 = 13;
+  const m = 5;
+  const n = 3864292196;
+  let i = 0;
+  const length = text.length;
+  let k1 = 0;
+  while (i < length) {
+    const char = text.charCodeAt(i++);
+    k1 = k1 << 8 | char;
+  }
+  k1 = k1 * c1 >>> 0;
+  k1 = (k1 << r1 | k1 >>> 32 - r1) >>> 0;
+  k1 = k1 * c2 >>> 0;
+  h1 ^= k1;
+  h1 = (h1 << r2 | h1 >>> 32 - r2) >>> 0;
+  h1 = h1 * m + n >>> 0;
+  h1 ^= length;
+  h1 ^= h1 >>> 16;
+  h1 = h1 * 2246822507 >>> 0;
+  h1 ^= h1 >>> 13;
+  h1 = h1 * 3266489909 >>> 0;
+  h1 ^= h1 >>> 16;
+  return h1;
+}
+function getTextHash(text) {
+  return murmurHash3(text);
+}
+
+// src/core/color.ts
+var ColorGenerator = class {
+  constructor(config = {}) {
+    __publicField(this, "config");
+    this.config = {
+      category: config.category || "default",
+      hue: config.hue || [0, 360],
+      saturation: config.saturation || [70, 100],
+      lightness: config.lightness || [40, 60],
+      algorithm: config.algorithm || "hash",
+      similarityThreshold: config.similarityThreshold || 0.7
+    };
+  }
+  // Generate color from hash value
+  generateColor(hash) {
+    const { hue, saturation, lightness } = this.config;
+    const hueRange = hue[1] - hue[0];
+    const calculatedHue = hue[0] + hash % hueRange;
+    const satRange = saturation[1] - saturation[0];
+    const calculatedSat = saturation[0] + (hash >> 8) % satRange;
+    const lightRange = lightness[1] - lightness[0];
+    const calculatedLight = lightness[0] + (hash >> 16) % lightRange;
+    return `hsl(${calculatedHue}, ${calculatedSat}%, ${calculatedLight}%)`;
+  }
+  // Get color for text (wrapper method)
+  getColor(text, hashFn) {
+    const hash = hashFn(text);
+    return this.generateColor(hash);
+  }
+};
+
+// src/vite-plugin.ts
+function createFilter(include, exclude) {
+  return function(id) {
+    const included = include.some((pattern) => {
+      if (pattern === "**/*") return true;
+      const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+      return regex.test(id);
+    });
+    const excluded = exclude && exclude.some((pattern) => {
+      const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+      return regex.test(id);
+    });
+    return included && !excluded;
+  };
+}
+function viteAutoColorPlugin() {
+  const filter = createFilter(["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx", "**/*.vue"]);
+  return {
+    name: "v-auto-color",
+    // Analyze code during build and inject precomputed colors
+    transform(code, id) {
+      if (!filter(id)) return null;
+      if (!code.includes("useAutoColor")) return null;
+      const useAutoColorRegex = /useAutoColor\s*\(\s*(?:(['"])([^'"]+)\1|\{[^}]*\})\s*\)/g;
+      const getColorRegex = /\.getColor\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+      let match;
+      const colorSets = /* @__PURE__ */ new Set();
+      while ((match = useAutoColorRegex.exec(code)) !== null) {
+        let category = "default";
+        if (match[2]) {
+          category = match[2];
+        } else {
+          const configMatch = match[0].match(/category\s*:\s*['"]([^'"]+)['"]/);
+          if (configMatch) {
+            category = configMatch[1];
+          }
+        }
+        colorSets.add(category);
+      }
+      const texts = /* @__PURE__ */ new Set();
+      while ((match = getColorRegex.exec(code)) !== null) {
+        texts.add(match[1]);
+      }
+      const colorUsage = {};
+      colorSets.forEach((category) => {
+        if (!colorUsage[category]) {
+          colorUsage[category] = {};
+        }
+        texts.forEach((text) => {
+          const generator = new ColorGenerator({ category });
+          const color = generator.getColor(text, getTextHash);
+          colorUsage[category][text] = color;
+        });
+      });
+      if (Object.keys(colorUsage).length > 0) {
+        const precomputedCode = `
+          // Precomputed colors for v-auto-color
+          import { __internal__setPrecomputedColors } from 'v-auto-color';
+          __internal__setPrecomputedColors(${JSON.stringify(colorUsage, null, 2)});
+        `;
+        code = precomputedCode + "\n" + code;
+      }
+      return code;
+    }
+  };
+}
+var vite_plugin_default = viteAutoColorPlugin;
+
+export {
+  __publicField,
+  getTextHash,
+  ColorGenerator,
+  viteAutoColorPlugin,
+  vite_plugin_default
+};

package/dist/index.d.mts

@@ -1,11 +1,14 @@
 export { default as viteAutoColorPlugin } from './vite-plugin.mjs';
 import 'vite';
 
+type AlgorithmType = 'hash' | 'levenshtein' | 'cosine' | 'jaccard';
 interface ColorConfig {
     category?: string;
     hue?: [number, number];
     saturation?: [number, number];
     lightness?: [number, number];
+    algorithm?: AlgorithmType;
+    similarityThreshold?: number;
 }
 
 declare class ColorSet {

package/dist/index.d.ts

@@ -1,11 +1,14 @@
 export { default as viteAutoColorPlugin } from './vite-plugin.js';
 import 'vite';
 
+type AlgorithmType = 'hash' | 'levenshtein' | 'cosine' | 'jaccard';
 interface ColorConfig {
     category?: string;
     hue?: [number, number];
     saturation?: [number, number];
     lightness?: [number, number];
+    algorithm?: AlgorithmType;
+    similarityThreshold?: number;
 }
 
 declare class ColorSet {

package/dist/index.js

@@ -71,7 +71,9 @@ var ColorGenerator = class {
       category: config.category || "default",
       hue: config.hue || [0, 360],
       saturation: config.saturation || [70, 100],
-      lightness: config.lightness || [40, 60]
+      lightness: config.lightness || [40, 60],
+      algorithm: config.algorithm || "hash",
+      similarityThreshold: config.similarityThreshold || 0.7
     };
   }
   // Generate color from hash value
@@ -92,6 +94,81 @@ var ColorGenerator = class {
   }
 };
 
+// src/core/similarity.ts
+function levenshteinDistance(str1, str2) {
+  const matrix = [];
+  for (let i = 0; i <= str2.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= str1.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= str2.length; i++) {
+    for (let j = 1; j <= str1.length; j++) {
+      if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          // substitution
+          matrix[i][j - 1] + 1,
+          // insertion
+          matrix[i - 1][j] + 1
+          // deletion
+        );
+      }
+    }
+  }
+  const maxLength = Math.max(str1.length, str2.length);
+  return maxLength === 0 ? 1 : 1 - matrix[str2.length][str1.length] / maxLength;
+}
+function cosineSimilarity(str1, str2) {
+  const freq1 = /* @__PURE__ */ new Map();
+  const freq2 = /* @__PURE__ */ new Map();
+  const allChars = /* @__PURE__ */ new Set();
+  for (const char of str1) {
+    freq1.set(char, (freq1.get(char) || 0) + 1);
+    allChars.add(char);
+  }
+  for (const char of str2) {
+    freq2.set(char, (freq2.get(char) || 0) + 1);
+    allChars.add(char);
+  }
+  let dotProduct = 0;
+  let magnitude1 = 0;
+  let magnitude2 = 0;
+  for (const char of allChars) {
+    const f1 = freq1.get(char) || 0;
+    const f2 = freq2.get(char) || 0;
+    dotProduct += f1 * f2;
+    magnitude1 += f1 * f1;
+    magnitude2 += f2 * f2;
+  }
+  if (magnitude1 === 0 || magnitude2 === 0) {
+    return 0;
+  }
+  return dotProduct / (Math.sqrt(magnitude1) * Math.sqrt(magnitude2));
+}
+function jaccardSimilarity(str1, str2) {
+  const set1 = new Set(str1);
+  const set2 = new Set(str2);
+  const intersection = new Set([...set1].filter((x) => set2.has(x)));
+  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
+  return union.size === 0 ? 0 : intersection.size / union.size;
+}
+function getSimilarityScore(str1, str2, algorithm) {
+  switch (algorithm) {
+    case "levenshtein":
+      return levenshteinDistance(str1, str2);
+    case "cosine":
+      return cosineSimilarity(str1, str2);
+    case "jaccard":
+      return jaccardSimilarity(str1, str2);
+    default:
+      return 0;
+  }
+}
+
 // src/vite-plugin.ts
 function createFilter(include, exclude) {
   return function(id) {
@@ -179,6 +256,23 @@ var ColorSet = class {
     if (precomputedColors[this.category] && precomputedColors[this.category][text]) {
       return precomputedColors[this.category][text];
     }
+    if (this.config.algorithm && this.config.algorithm !== "hash" && precomputedColors[this.category]) {
+      const similarityThreshold = this.config.similarityThreshold || 0.7;
+      let mostSimilarText = text;
+      let highestSimilarity = 0;
+      for (const existingText in precomputedColors[this.category]) {
+        const similarity = getSimilarityScore(text, existingText, this.config.algorithm);
+        if (similarity > highestSimilarity && similarity >= similarityThreshold) {
+          highestSimilarity = similarity;
+          mostSimilarText = existingText;
+        }
+      }
+      if (mostSimilarText !== text && precomputedColors[this.category][mostSimilarText]) {
+        const color2 = precomputedColors[this.category][mostSimilarText];
+        precomputedColors[this.category][text] = color2;
+        return color2;
+      }
+    }
     const color = this.generator.getColor(text, getTextHash);
     if (!precomputedColors[this.category]) {
       precomputedColors[this.category] = {};

package/dist/index.mjs

@@ -3,7 +3,82 @@ import {
   __publicField,
   getTextHash,
   viteAutoColorPlugin
-} from "./chunk-6X3GUPCU.mjs";
+} from "./chunk-RECQIKGP.mjs";
+
+// src/core/similarity.ts
+function levenshteinDistance(str1, str2) {
+  const matrix = [];
+  for (let i = 0; i <= str2.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= str1.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= str2.length; i++) {
+    for (let j = 1; j <= str1.length; j++) {
+      if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          // substitution
+          matrix[i][j - 1] + 1,
+          // insertion
+          matrix[i - 1][j] + 1
+          // deletion
+        );
+      }
+    }
+  }
+  const maxLength = Math.max(str1.length, str2.length);
+  return maxLength === 0 ? 1 : 1 - matrix[str2.length][str1.length] / maxLength;
+}
+function cosineSimilarity(str1, str2) {
+  const freq1 = /* @__PURE__ */ new Map();
+  const freq2 = /* @__PURE__ */ new Map();
+  const allChars = /* @__PURE__ */ new Set();
+  for (const char of str1) {
+    freq1.set(char, (freq1.get(char) || 0) + 1);
+    allChars.add(char);
+  }
+  for (const char of str2) {
+    freq2.set(char, (freq2.get(char) || 0) + 1);
+    allChars.add(char);
+  }
+  let dotProduct = 0;
+  let magnitude1 = 0;
+  let magnitude2 = 0;
+  for (const char of allChars) {
+    const f1 = freq1.get(char) || 0;
+    const f2 = freq2.get(char) || 0;
+    dotProduct += f1 * f2;
+    magnitude1 += f1 * f1;
+    magnitude2 += f2 * f2;
+  }
+  if (magnitude1 === 0 || magnitude2 === 0) {
+    return 0;
+  }
+  return dotProduct / (Math.sqrt(magnitude1) * Math.sqrt(magnitude2));
+}
+function jaccardSimilarity(str1, str2) {
+  const set1 = new Set(str1);
+  const set2 = new Set(str2);
+  const intersection = new Set([...set1].filter((x) => set2.has(x)));
+  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
+  return union.size === 0 ? 0 : intersection.size / union.size;
+}
+function getSimilarityScore(str1, str2, algorithm) {
+  switch (algorithm) {
+    case "levenshtein":
+      return levenshteinDistance(str1, str2);
+    case "cosine":
+      return cosineSimilarity(str1, str2);
+    case "jaccard":
+      return jaccardSimilarity(str1, str2);
+    default:
+      return 0;
+  }
+}
 
 // src/index.ts
 var precomputedColors = {};
@@ -25,6 +100,23 @@ var ColorSet = class {
     if (precomputedColors[this.category] && precomputedColors[this.category][text]) {
       return precomputedColors[this.category][text];
     }
+    if (this.config.algorithm && this.config.algorithm !== "hash" && precomputedColors[this.category]) {
+      const similarityThreshold = this.config.similarityThreshold || 0.7;
+      let mostSimilarText = text;
+      let highestSimilarity = 0;
+      for (const existingText in precomputedColors[this.category]) {
+        const similarity = getSimilarityScore(text, existingText, this.config.algorithm);
+        if (similarity > highestSimilarity && similarity >= similarityThreshold) {
+          highestSimilarity = similarity;
+          mostSimilarText = existingText;
+        }
+      }
+      if (mostSimilarText !== text && precomputedColors[this.category][mostSimilarText]) {
+        const color2 = precomputedColors[this.category][mostSimilarText];
+        precomputedColors[this.category][text] = color2;
+        return color2;
+      }
+    }
     const color = this.generator.getColor(text, getTextHash);
     if (!precomputedColors[this.category]) {
       precomputedColors[this.category] = {};

package/dist/vite-plugin.js

@@ -69,7 +69,9 @@ var ColorGenerator = class {
       category: config.category || "default",
       hue: config.hue || [0, 360],
       saturation: config.saturation || [70, 100],
-      lightness: config.lightness || [40, 60]
+      lightness: config.lightness || [40, 60],
+      algorithm: config.algorithm || "hash",
+      similarityThreshold: config.similarityThreshold || 0.7
     };
   }
   // Generate color from hash value

package/dist/vite-plugin.mjs

@@ -1,7 +1,7 @@
 import {
   viteAutoColorPlugin,
   vite_plugin_default
-} from "./chunk-6X3GUPCU.mjs";
+} from "./chunk-RECQIKGP.mjs";
 export {
   vite_plugin_default as default,
   viteAutoColorPlugin

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "v-auto-color",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Vite plugin for automatic color generation based on text similarity",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/core/color.ts

@@ -1,9 +1,13 @@
 // Color generation based on hash values
+export type AlgorithmType = 'hash' | 'levenshtein' | 'cosine' | 'jaccard';
+
 export interface ColorConfig {
   category?: string;
   hue?: [number, number];
   saturation?: [number, number];
   lightness?: [number, number];
+  algorithm?: AlgorithmType;
+  similarityThreshold?: number; // 相似度阈值，用于相似度算法
 }
 
 export class ColorGenerator {
@@ -14,7 +18,9 @@ export class ColorGenerator {
       category: config.category || 'default',
       hue: config.hue || [0, 360],
       saturation: config.saturation || [70, 100],
-      lightness: config.lightness || [40, 60]
+      lightness: config.lightness || [40, 60],
+      algorithm: config.algorithm || 'hash',
+      similarityThreshold: config.similarityThreshold || 0.7
     };
   }
 

package/src/core/similarity.ts

@@ -0,0 +1,95 @@
+// String similarity algorithms
+
+// Levenshtein distance algorithm (edit distance)
+export function levenshteinDistance(str1: string, str2: string): number {
+  const matrix: number[][] = [];
+
+  // Initialize matrix
+  for (let i = 0; i <= str2.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= str1.length; j++) {
+    matrix[0][j] = j;
+  }
+
+  // Calculate Levenshtein distance
+  for (let i = 1; i <= str2.length; i++) {
+    for (let j = 1; j <= str1.length; j++) {
+      if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1, // substitution
+          matrix[i][j - 1] + 1,     // insertion
+          matrix[i - 1][j] + 1      // deletion
+        );
+      }
+    }
+  }
+
+  // Calculate similarity score (0-1)
+  const maxLength = Math.max(str1.length, str2.length);
+  return maxLength === 0 ? 1 : 1 - matrix[str2.length][str1.length] / maxLength;
+}
+
+// Cosine similarity algorithm
+export function cosineSimilarity(str1: string, str2: string): number {
+  // Create character frequency maps
+  const freq1 = new Map<string, number>();
+  const freq2 = new Map<string, number>();
+  const allChars = new Set<string>();
+
+  // Count frequencies for str1
+  for (const char of str1) {
+    freq1.set(char, (freq1.get(char) || 0) + 1);
+    allChars.add(char);
+  }
+
+  // Count frequencies for str2
+  for (const char of str2) {
+    freq2.set(char, (freq2.get(char) || 0) + 1);
+    allChars.add(char);
+  }
+
+  // Calculate dot product
+  let dotProduct = 0;
+  let magnitude1 = 0;
+  let magnitude2 = 0;
+
+  for (const char of allChars) {
+    const f1 = freq1.get(char) || 0;
+    const f2 = freq2.get(char) || 0;
+    dotProduct += f1 * f2;
+    magnitude1 += f1 * f1;
+    magnitude2 += f2 * f2;
+  }
+
+  // Calculate cosine similarity
+  if (magnitude1 === 0 || magnitude2 === 0) {
+    return 0;
+  }
+  return dotProduct / (Math.sqrt(magnitude1) * Math.sqrt(magnitude2));
+}
+
+// Jaccard similarity algorithm
+export function jaccardSimilarity(str1: string, str2: string): number {
+  const set1 = new Set(str1);
+  const set2 = new Set(str2);
+  const intersection = new Set([...set1].filter(x => set2.has(x)));
+  const union = new Set([...set1, ...set2]);
+  return union.size === 0 ? 0 : intersection.size / union.size;
+}
+
+// Get similarity score based on algorithm
+export function getSimilarityScore(str1: string, str2: string, algorithm: 'levenshtein' | 'cosine' | 'jaccard'): number {
+  switch (algorithm) {
+    case 'levenshtein':
+      return levenshteinDistance(str1, str2);
+    case 'cosine':
+      return cosineSimilarity(str1, str2);
+    case 'jaccard':
+      return jaccardSimilarity(str1, str2);
+    default:
+      return 0;
+  }
+}

package/src/index.ts

@@ -1,5 +1,6 @@
 import { getTextHash } from './core/hash';
 import { ColorConfig, ColorGenerator } from './core/color';
+import { getSimilarityScore } from './core/similarity';
 import { viteAutoColorPlugin } from './vite-plugin';
 
 // Precomputed colors cache (filled by Vite plugin at build time)
@@ -29,7 +30,31 @@ export class ColorSet {
       return precomputedColors[this.category][text];
     }
 
-    // Generate color at runtime if not precomputed
+    // Check for similar strings in the same category (if using similarity algorithm)
+    if (this.config.algorithm && this.config.algorithm !== 'hash' && precomputedColors[this.category]) {
+      const similarityThreshold = this.config.similarityThreshold || 0.7;
+      let mostSimilarText = text;
+      let highestSimilarity = 0;
+
+      // Find most similar text in the category
+      for (const existingText in precomputedColors[this.category]) {
+        const similarity = getSimilarityScore(text, existingText, this.config.algorithm as 'levenshtein' | 'cosine' | 'jaccard');
+        if (similarity > highestSimilarity && similarity >= similarityThreshold) {
+          highestSimilarity = similarity;
+          mostSimilarText = existingText;
+        }
+      }
+
+      // Use color from most similar text if found
+      if (mostSimilarText !== text && precomputedColors[this.category][mostSimilarText]) {
+        const color = precomputedColors[this.category][mostSimilarText];
+        // Cache the color for current text
+        precomputedColors[this.category][text] = color;
+        return color;
+      }
+    }
+
+    // Generate color at runtime if not precomputed and no similar text found
     const color = this.generator.getColor(text, getTextHash);
     
     // Cache the generated color for future use