v-auto-color 1.0.0

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zeki T. Luan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,203 @@
+# Vue-AutoColor
+
+一个兼容 vite/typescript/vue 环境的 node module，用于在 vite 编译时实现基于文本的自动颜色生成。相似的文本会返回相似的颜色，从而实现视觉上的一致性。
+
+## 功能特点
+
+- **基于文本的颜色生成**：根据纯文本计算颜色，相似的文本返回相似的颜色
+- **编译时优化**：在 vite 编译时预先计算已使用的颜色，降低运行时负载
+- **运行时 fallback**：对于未预编译的颜色，在运行时自动生成并缓存
+- **支持自定义配置**：可以配置颜色的色相范围、饱和度范围和亮度范围
+- **TypeScript 支持**：完整的类型定义，提供良好的开发体验
+- **Vue 兼容**：可以在 Vue 组件中轻松使用
+
+## 安装
+
+```bash
+npm install v-auto-color
+# 或
+yarn add v-auto-color
+# 或
+pnpm add v-auto-color
+```
+
+## 使用方法
+
+### 1. 在 vite.config.ts 中配置插件
+
+```typescript
+import { defineConfig } from 'vite';
+import vue from '@vitejs/plugin-vue';
+import { viteAutoColorPlugin } from 'v-auto-color';
+
+export default defineConfig({
+  plugins: [
+    vue(),
+    viteAutoColorPlugin() // 启用 v-auto-color 插件
+  ],
+});
+```
+
+### 2. 在代码中使用
+
+```typescript
+import { useAutoColor } from 'v-auto-color';
+
+// 使用默认配置
+const colorSet1 = useAutoColor('set1');
+const color1 = colorSet1.getColor('text');
+
+// 使用自定义配置
+const colorSet2 = useAutoColor({
+  category: 'set2',
+  hue: [180, 360], // 蓝色调范围
+  saturation: [60, 90],
+  lightness: [40, 70]
+});
+const color2 = colorSet2.getColor('text');
+```
+
+### 3. 在 Vue 组件中使用
+
+```vue
+<template>
+  <div :style="`--color: ${colorSet1.getColor('text')}`">text</div>
+</template>
+
+<script setup lang="ts">
+import { useAutoColor } from 'v-auto-color';
+
+const colorSet1 = useAutoColor('set1');
+</script>
+```
+
+## 配置选项
+
+### useAutoColor 配置
+
+```typescript
+interface ColorConfig {
+  category?: string;  // 颜色集类别，默认 'default'
+  hue?: [number, number];  // 色相范围，默认 [0, 360]
+  saturation?: [number, number];  // 饱和度范围，默认 [70, 100]
+  lightness?: [number, number];  // 亮度范围，默认 [40, 60]
+}
+
+// 两种使用方式
+const colorSet1 = useAutoColor('category'); // 使用字符串作为类别
+const colorSet2 = useAutoColor({ /* 完整配置 */ }); // 使用对象配置
+```
+
+## 性能优化
+
+### 编译时预计算
+
+插件会在 vite 编译时分析代码，提取所有 `useAutoColor` 和 `getColor` 的调用，预先计算出所有使用的颜色，并在构建时注入到代码中。这样在运行时，大部分颜色都可以直接从缓存中获取，无需重新计算。
+
+### 运行时缓存
+
+对于未在编译时预计算的颜色（例如动态生成的文本），插件会在运行时生成颜色并缓存起来，避免重复计算。
+
+### 哈希算法优化
+
+使用 MurmurHash3 算法计算文本哈希值，该算法具有以下特点：
+- 计算速度快
+- 分布均匀
+- 碰撞率低
+
+## 工作原理
+
+1. **文本哈希**：使用 MurmurHash3 算法对文本进行哈希计算，得到一个数值
+2. **颜色生成**：根据哈希值计算 HSL 颜色，确保相似的文本返回相似的颜色
+3. **编译时分析**：在 vite 编译时分析代码，提取颜色使用情况
+4. **预计算颜色**：为提取的文本预先计算颜色
+5. **运行时使用**：在运行时优先使用预计算的颜色，未预计算的则动态生成
+
+## 示例
+
+### 基本示例
+
+```typescript
+import { useAutoColor } from 'v-auto-color';
+
+const colorSet = useAutoColor('default');
+
+// 相似的文本会返回相似的颜色
+const color1 = colorSet.getColor('hello');
+const color2 = colorSet.getColor('hello world');
+const color3 = colorSet.getColor('hello there');
+
+console.log(color1); // 例如: hsl(120, 80%, 50%)
+console.log(color2); // 例如: hsl(125, 75%, 45%)
+console.log(color3); // 例如: hsl(115, 85%, 55%)
+```
+
+### Vue 组件示例
+
+```vue
+<template>
+  <div class="tag-container">
+    <span 
+      v-for="tag in tags" 
+      :key="tag"
+      class="tag"
+      :style="`--tag-color: ${colorSet.getColor(tag)}`"
+    >
+      {{ tag }}
+    </span>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { useAutoColor } from 'v-auto-color';
+
+const colorSet = useAutoColor('tags');
+const tags = ['JavaScript', 'TypeScript', 'Vue', 'React', 'Node.js'];
+</script>
+
+<style scoped>
+.tag {
+  display: inline-block;
+  padding: 4px 12px;
+  margin: 4px;
+  background-color: var(--tag-color);
+  color: white;
+  border-radius: 16px;
+  font-size: 14px;
+}
+</style>
+```
+
+## 常见问题
+
+### 颜色不一致
+
+如果发现相似的文本返回的颜色差异较大，可能是因为：
+- 文本差异过大，导致哈希值差异较大
+- 色相范围设置过小，导致颜色变化不明显
+
+可以尝试调整 `hue` 配置选项，扩大色相范围。
+
+### 性能问题
+
+对于大量动态文本的场景，建议：
+- 尽可能在编译时确定文本内容，以便插件能够预计算颜色
+- 对于动态生成的文本，可以考虑缓存结果，避免重复调用 `getColor`
+
+### 颜色质量
+
+如果生成的颜色质量不佳，可以调整配置选项：
+- `saturation`：调整颜色的饱和度，值越高颜色越鲜艳
+- `lightness`：调整颜色的亮度，值适中时颜色效果最好
+
+## 浏览器兼容性
+
+本插件生成的是标准的 HSL 颜色值，支持所有现代浏览器。对于 IE11 等旧浏览器，可能需要使用 HEX 颜色值的 polyfill。
+
+## 许可证
+
+MIT License
+
+## 贡献
+
+欢迎提交 Issue 和 Pull Request！

package/dist/chunk-GO6JHW6J.mjs

@@ -0,0 +1,72 @@
+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]
+    };
+  }
+  // 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);
+  }
+};
+
+export {
+  __publicField,
+  getTextHash,
+  ColorGenerator
+};

package/dist/index.d.mts

@@ -0,0 +1,18 @@
+interface ColorConfig {
+    category?: string;
+    hue?: [number, number];
+    saturation?: [number, number];
+    lightness?: [number, number];
+}
+
+declare class ColorSet {
+    private config;
+    private generator;
+    private category;
+    constructor(config?: ColorConfig | string);
+    getColor(text: string): string;
+}
+declare function useAutoColor(config?: ColorConfig | string): ColorSet;
+declare function __internal__setPrecomputedColors(colors: Record<string, Record<string, string>>): void;
+
+export { type ColorConfig, ColorSet, __internal__setPrecomputedColors, useAutoColor };

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+interface ColorConfig {
+    category?: string;
+    hue?: [number, number];
+    saturation?: [number, number];
+    lightness?: [number, number];
+}
+
+declare class ColorSet {
+    private config;
+    private generator;
+    private category;
+    constructor(config?: ColorConfig | string);
+    getColor(text: string): string;
+}
+declare function useAutoColor(config?: ColorConfig | string): ColorSet;
+declare function __internal__setPrecomputedColors(colors: Record<string, Record<string, string>>): void;
+
+export { type ColorConfig, ColorSet, __internal__setPrecomputedColors, useAutoColor };

package/dist/index.js

@@ -0,0 +1,133 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ColorSet: () => ColorSet,
+  __internal__setPrecomputedColors: () => __internal__setPrecomputedColors,
+  useAutoColor: () => useAutoColor
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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]
+    };
+  }
+  // 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/index.ts
+var precomputedColors = {};
+var ColorSet = class {
+  constructor(config = "default") {
+    __publicField(this, "config");
+    __publicField(this, "generator");
+    __publicField(this, "category");
+    if (typeof config === "string") {
+      this.config = { category: config };
+    } else {
+      this.config = config;
+    }
+    this.category = this.config.category || "default";
+    this.generator = new ColorGenerator(this.config);
+  }
+  // Get color for text
+  getColor(text) {
+    if (precomputedColors[this.category] && precomputedColors[this.category][text]) {
+      return precomputedColors[this.category][text];
+    }
+    const color = this.generator.getColor(text, getTextHash);
+    if (!precomputedColors[this.category]) {
+      precomputedColors[this.category] = {};
+    }
+    precomputedColors[this.category][text] = color;
+    return color;
+  }
+};
+function useAutoColor(config = "default") {
+  return new ColorSet(config);
+}
+function __internal__setPrecomputedColors(colors) {
+  Object.assign(precomputedColors, colors);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ColorSet,
+  __internal__setPrecomputedColors,
+  useAutoColor
+});

package/dist/index.mjs

@@ -0,0 +1,45 @@
+import {
+  ColorGenerator,
+  __publicField,
+  getTextHash
+} from "./chunk-GO6JHW6J.mjs";
+
+// src/index.ts
+var precomputedColors = {};
+var ColorSet = class {
+  constructor(config = "default") {
+    __publicField(this, "config");
+    __publicField(this, "generator");
+    __publicField(this, "category");
+    if (typeof config === "string") {
+      this.config = { category: config };
+    } else {
+      this.config = config;
+    }
+    this.category = this.config.category || "default";
+    this.generator = new ColorGenerator(this.config);
+  }
+  // Get color for text
+  getColor(text) {
+    if (precomputedColors[this.category] && precomputedColors[this.category][text]) {
+      return precomputedColors[this.category][text];
+    }
+    const color = this.generator.getColor(text, getTextHash);
+    if (!precomputedColors[this.category]) {
+      precomputedColors[this.category] = {};
+    }
+    precomputedColors[this.category][text] = color;
+    return color;
+  }
+};
+function useAutoColor(config = "default") {
+  return new ColorSet(config);
+}
+function __internal__setPrecomputedColors(colors) {
+  Object.assign(precomputedColors, colors);
+}
+export {
+  ColorSet,
+  __internal__setPrecomputedColors,
+  useAutoColor
+};

package/dist/vite-plugin.d.mts

@@ -0,0 +1,5 @@
+import { Plugin } from 'vite';
+
+declare function viteAutoColorPlugin(): Plugin;
+
+export { viteAutoColorPlugin as default, viteAutoColorPlugin };

package/dist/vite-plugin.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from 'vite';
+
+declare function viteAutoColorPlugin(): Plugin;
+
+export { viteAutoColorPlugin as default, viteAutoColorPlugin };

package/dist/vite-plugin.js

@@ -0,0 +1,158 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/vite-plugin.ts
+var vite_plugin_exports = {};
+__export(vite_plugin_exports, {
+  default: () => vite_plugin_default,
+  viteAutoColorPlugin: () => viteAutoColorPlugin
+});
+module.exports = __toCommonJS(vite_plugin_exports);
+var import_pluginutils = require("@rollup/pluginutils");
+
+// 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]
+    };
+  }
+  // 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 viteAutoColorPlugin() {
+  const filter = (0, import_pluginutils.createFilter)(["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx", "**/*.vue"]);
+  const colorUsage = {};
+  return {
+    name: "v-auto-color",
+    // Analyze code during build
+    transform(code, id) {
+      if (!filter(id)) 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]);
+      }
+      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;
+        });
+      });
+      return null;
+    },
+    // Generate precomputed colors module
+    generateBundle() {
+      const precomputedCode = `
+        import { __internal__setPrecomputedColors } from 'v-auto-color';
+        __internal__setPrecomputedColors(${JSON.stringify(colorUsage, null, 2)});
+      `;
+      this.emitFile({
+        type: "asset",
+        fileName: "v-auto-color-precomputed.js",
+        source: precomputedCode
+      });
+      this.emitFile({
+        type: "asset",
+        fileName: "v-auto-color-initializer.js",
+        source: `import "/v-auto-color-precomputed.js";`
+      });
+    }
+  };
+}
+var vite_plugin_default = viteAutoColorPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  viteAutoColorPlugin
+});

package/dist/vite-plugin.mjs

@@ -0,0 +1,71 @@
+import {
+  ColorGenerator,
+  getTextHash
+} from "./chunk-GO6JHW6J.mjs";
+
+// src/vite-plugin.ts
+import { createFilter } from "@rollup/pluginutils";
+function viteAutoColorPlugin() {
+  const filter = createFilter(["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx", "**/*.vue"]);
+  const colorUsage = {};
+  return {
+    name: "v-auto-color",
+    // Analyze code during build
+    transform(code, id) {
+      if (!filter(id)) 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]);
+      }
+      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;
+        });
+      });
+      return null;
+    },
+    // Generate precomputed colors module
+    generateBundle() {
+      const precomputedCode = `
+        import { __internal__setPrecomputedColors } from 'v-auto-color';
+        __internal__setPrecomputedColors(${JSON.stringify(colorUsage, null, 2)});
+      `;
+      this.emitFile({
+        type: "asset",
+        fileName: "v-auto-color-precomputed.js",
+        source: precomputedCode
+      });
+      this.emitFile({
+        type: "asset",
+        fileName: "v-auto-color-initializer.js",
+        source: `import "/v-auto-color-precomputed.js";`
+      });
+    }
+  };
+}
+var vite_plugin_default = viteAutoColorPlugin;
+export {
+  vite_plugin_default as default,
+  viteAutoColorPlugin
+};

package/examples/VueExample.vue

@@ -0,0 +1,77 @@
+<template>
+  <div class="example-container">
+    <h1>v-auto-color 示例</h1>
+    
+    <!-- 使用默认配置的颜色集 -->
+    <div class="color-set">
+      <h2>默认配置颜色集</h2>
+      <div 
+        v-for="text in texts" 
+        :key="text"
+        class="color-item"
+        :style="`--color: ${colorSet1.getColor(text)}`"
+      >
+        {{ text }}
+      </div>
+    </div>
+
+    <!-- 使用自定义配置的颜色集 -->
+    <div class="color-set">
+      <h2>自定义配置颜色集</h2>
+      <div 
+        v-for="text in texts" 
+        :key="text"
+        class="color-item"
+        :style="`--color: ${colorSet2.getColor(text)}`"
+      >
+        {{ text }}
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { useAutoColor } from 'v-auto-color';
+
+// 默认配置的颜色集
+const colorSet1 = useAutoColor('set1');
+
+// 自定义配置的颜色集
+const colorSet2 = useAutoColor({
+  category: 'set2',
+  hue: [180, 360], // 蓝色调范围
+  saturation: [60, 90],
+  lightness: [40, 70]
+});
+
+// 测试文本
+const texts = [
+  'Hello World',
+  'Test Text',
+  'Another Example',
+  'Similar Text',
+  'Different Content'
+];
+</script>
+
+<style scoped>
+.example-container {
+  max-width: 800px;
+  margin: 0 auto;
+  padding: 20px;
+}
+
+.color-set {
+  margin-bottom: 30px;
+}
+
+.color-item {
+  display: inline-block;
+  padding: 10px 20px;
+  margin: 5px;
+  background-color: var(--color);
+  color: white;
+  border-radius: 4px;
+  font-weight: bold;
+}
+</style>

package/examples/vite.config.example.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vite';
+import vue from '@vitejs/plugin-vue';
+import { viteAutoColorPlugin } from 'v-auto-color';
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [
+    vue(),
+    viteAutoColorPlugin() // 启用v-auto-color插件
+  ],
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "v-auto-color",
+  "version": "1.0.0",
+  "description": "Vite plugin for automatic color generation based on text similarity",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/vite-plugin.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts src/vite-plugin.ts --format cjs,esm --dts --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "vite",
+    "plugin",
+    "color",
+    "auto-color",
+    "text-similarity",
+    "vue",
+    "typescript"
+  ],
+  "author": "",
+  "license": "MIT",
+  "peerDependencies": {
+    "vite": "^4.0.0 || ^5.0.0"
+  },
+  "dependencies": {
+    "@rollup/pluginutils": "^5.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^18.19.3",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vite": "^5.0.10"
+  }
+}

package/src/core/color.ts

@@ -0,0 +1,46 @@
+// Color generation based on hash values
+export interface ColorConfig {
+  category?: string;
+  hue?: [number, number];
+  saturation?: [number, number];
+  lightness?: [number, number];
+}
+
+export class ColorGenerator {
+  private config: Required<ColorConfig>;
+
+  constructor(config: ColorConfig = {}) {
+    this.config = {
+      category: config.category || 'default',
+      hue: config.hue || [0, 360],
+      saturation: config.saturation || [70, 100],
+      lightness: config.lightness || [40, 60]
+    };
+  }
+
+  // Generate color from hash value
+  generateColor(hash: number): string {
+    const { hue, saturation, lightness } = this.config;
+
+    // Calculate hue based on hash
+    const hueRange = hue[1] - hue[0];
+    const calculatedHue = hue[0] + (hash % hueRange);
+
+    // Calculate saturation based on hash
+    const satRange = saturation[1] - saturation[0];
+    const calculatedSat = saturation[0] + ((hash >> 8) % satRange);
+
+    // Calculate lightness based on hash
+    const lightRange = lightness[1] - lightness[0];
+    const calculatedLight = lightness[0] + ((hash >> 16) % lightRange);
+
+    // Return HSL color string
+    return `hsl(${calculatedHue}, ${calculatedSat}%, ${calculatedLight}%)`;
+  }
+
+  // Get color for text (wrapper method)
+  getColor(text: string, hashFn: (text: string) => number): string {
+    const hash = hashFn(text);
+    return this.generateColor(hash);
+  }
+}

package/src/core/hash.ts

@@ -0,0 +1,44 @@
+// MurmurHash3 implementation for text hashing
+// Based on https://github.com/garycourt/murmurhash-js
+
+export function murmurHash3(text: string): number {
+  let h1 = 0xdeadbeef; // Seed value
+  const c1 = 0xcc9e2d51;
+  const c2 = 0x1b873593;
+  const r1 = 15;
+  const r2 = 13;
+  const m = 5;
+  const n = 0xe6546b64;
+
+  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;
+
+  // Finalization
+  h1 ^= length;
+  h1 ^= h1 >>> 16;
+  h1 = (h1 * 0x85ebca6b) >>> 0;
+  h1 ^= h1 >>> 13;
+  h1 = (h1 * 0xc2b2ae35) >>> 0;
+  h1 ^= h1 >>> 16;
+
+  return h1;
+}
+
+// Generate a hash from text
+export function getTextHash(text: string): number {
+  return murmurHash3(text);
+}

package/src/index.ts

@@ -0,0 +1,55 @@
+import { getTextHash } from './core/hash';
+import { ColorConfig, ColorGenerator } from './core/color';
+
+// Precomputed colors cache (filled by Vite plugin at build time)
+const precomputedColors: Record<string, Record<string, string>> = {};
+
+// ColorSet class for managing color generation
+export class ColorSet {
+  private config: ColorConfig;
+  private generator: ColorGenerator;
+  private category: string;
+
+  constructor(config: ColorConfig | string = 'default') {
+    if (typeof config === 'string') {
+      this.config = { category: config };
+    } else {
+      this.config = config;
+    }
+
+    this.category = this.config.category || 'default';
+    this.generator = new ColorGenerator(this.config);
+  }
+
+  // Get color for text
+  getColor(text: string): string {
+    // Check if color is precomputed
+    if (precomputedColors[this.category] && precomputedColors[this.category][text]) {
+      return precomputedColors[this.category][text];
+    }
+
+    // Generate color at runtime if not precomputed
+    const color = this.generator.getColor(text, getTextHash);
+    
+    // Cache the generated color for future use
+    if (!precomputedColors[this.category]) {
+      precomputedColors[this.category] = {};
+    }
+    precomputedColors[this.category][text] = color;
+
+    return color;
+  }
+}
+
+// Main function to create ColorSet instances
+export function useAutoColor(config: ColorConfig | string = 'default'): ColorSet {
+  return new ColorSet(config);
+}
+
+// Expose precomputed colors for Vite plugin to fill
+export function __internal__setPrecomputedColors(colors: Record<string, Record<string, string>>): void {
+  Object.assign(precomputedColors, colors);
+}
+
+// Export types
+export type { ColorConfig };

package/src/vite-plugin.ts

@@ -0,0 +1,91 @@
+import { Plugin } from 'vite';
+import { createFilter } from '@rollup/pluginutils';
+import { getTextHash } from './core/hash';
+import { ColorGenerator } from './core/color';
+
+// Vite plugin for precomputing colors at build time
+export function viteAutoColorPlugin(): Plugin {
+  const filter = createFilter(['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', '**/*.vue']);
+  
+  // Collected color usage data
+  const colorUsage: Record<string, Record<string, string>> = {};
+
+  return {
+    name: 'v-auto-color',
+
+    // Analyze code during build
+    transform(code, id) {
+      if (!filter(id)) return null;
+
+      // Extract useAutoColor calls and getColor calls
+      const useAutoColorRegex = /useAutoColor\s*\(\s*(?:(['"])([^'"]+)\1|\{[^}]*\})\s*\)/g;
+      const getColorRegex = /\.getColor\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+
+      let match;
+      const colorSets = new Set<string>();
+
+      // Extract color set configurations
+      while ((match = useAutoColorRegex.exec(code)) !== null) {
+        let category = 'default';
+        if (match[2]) {
+          // String configuration
+          category = match[2];
+        } else {
+          // Object configuration - extract category
+          const configMatch = match[0].match(/category\s*:\s*['"]([^'"]+)['"]/);
+          if (configMatch) {
+            category = configMatch[1];
+          }
+        }
+        colorSets.add(category);
+      }
+
+      // Extract text parameters from getColor calls
+      const texts = new Set<string>();
+      while ((match = getColorRegex.exec(code)) !== null) {
+        texts.add(match[1]);
+      }
+
+      // Precompute colors for extracted texts
+      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;
+        });
+      });
+
+      return null;
+    },
+
+    // Generate precomputed colors module
+    generateBundle() {
+      // Create precomputed colors code
+      const precomputedCode = `
+        import { __internal__setPrecomputedColors } from 'v-auto-color';
+        __internal__setPrecomputedColors(${JSON.stringify(colorUsage, null, 2)});
+      `;
+
+      // Add precomputed colors module to bundle
+      this.emitFile({
+        type: 'asset',
+        fileName: 'v-auto-color-precomputed.js',
+        source: precomputedCode
+      });
+
+      // Ensure the precomputed module is loaded before application code
+      this.emitFile({
+        type: 'asset',
+        fileName: 'v-auto-color-initializer.js',
+        source: `import "/v-auto-color-precomputed.js";`
+      });
+    }
+  };
+}
+
+// Export plugin
+export default viteAutoColorPlugin;

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

package/tsconfig.node.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["vite.config.ts"]
+}