v-auto-color 1.0.1 → 1.0.3

package/dist/chunk-NJGGDAAU.mjs

@@ -0,0 +1,140 @@
+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/vite-plugin.ts
+import { createFilter } from "@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 = 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
+      });
+    },
+    // Inject precomputed colors into HTML
+    transformIndexHtml(html) {
+      return html.replace("</head>", `
+        <script type="module" src="/v-auto-color-precomputed.js"></script>
+      </head>`);
+    }
+  };
+}
+var vite_plugin_default = viteAutoColorPlugin;
+
+export {
+  __publicField,
+  getTextHash,
+  ColorGenerator,
+  viteAutoColorPlugin,
+  vite_plugin_default
+};

package/dist/chunk-VOGH5JNO.mjs

@@ -0,0 +1,139 @@
+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/vite-plugin.ts
+import { createFilter } from "@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 = 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 {
+  __publicField,
+  getTextHash,
+  ColorGenerator,
+  viteAutoColorPlugin,
+  vite_plugin_default
+};

package/dist/index.d.mts

@@ -1,3 +1,6 @@
+export { default as viteAutoColorPlugin } from './vite-plugin.mjs';
+import 'vite';
+
 interface ColorConfig {
     category?: string;
     hue?: [number, number];

package/dist/index.d.ts

@@ -1,3 +1,6 @@
+export { default as viteAutoColorPlugin } from './vite-plugin.js';
+import 'vite';
+
 interface ColorConfig {
     category?: string;
     hue?: [number, number];

package/dist/index.js

@@ -24,7 +24,8 @@ var index_exports = {};
 __export(index_exports, {
   ColorSet: () => ColorSet,
   __internal__setPrecomputedColors: () => __internal__setPrecomputedColors,
-  useAutoColor: () => useAutoColor
+  useAutoColor: () => useAutoColor,
+  viteAutoColorPlugin: () => viteAutoColorPlugin
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -91,6 +92,69 @@ var ColorGenerator = class {
   }
 };
 
+// src/vite-plugin.ts
+var import_pluginutils = require("@rollup/pluginutils");
+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
+      });
+    },
+    // Inject precomputed colors into HTML
+    transformIndexHtml(html) {
+      return html.replace("</head>", `
+        <script type="module" src="/v-auto-color-precomputed.js"></script>
+      </head>`);
+    }
+  };
+}
+
 // src/index.ts
 var precomputedColors = {};
 var ColorSet = class {
@@ -129,5 +193,6 @@ function __internal__setPrecomputedColors(colors) {
 0 && (module.exports = {
   ColorSet,
   __internal__setPrecomputedColors,
-  useAutoColor
+  useAutoColor,
+  viteAutoColorPlugin
 });

package/dist/index.mjs

@@ -1,8 +1,9 @@
 import {
   ColorGenerator,
   __publicField,
-  getTextHash
-} from "./chunk-GO6JHW6J.mjs";
+  getTextHash,
+  viteAutoColorPlugin
+} from "./chunk-NJGGDAAU.mjs";
 
 // src/index.ts
 var precomputedColors = {};
@@ -41,5 +42,6 @@ function __internal__setPrecomputedColors(colors) {
 export {
   ColorSet,
   __internal__setPrecomputedColors,
-  useAutoColor
+  useAutoColor,
+  viteAutoColorPlugin
 };

package/dist/vite-plugin.js

@@ -143,11 +143,12 @@ function viteAutoColorPlugin() {
         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";`
-      });
+    },
+    // Inject precomputed colors into HTML
+    transformIndexHtml(html) {
+      return html.replace("</head>", `
+        <script type="module" src="/v-auto-color-precomputed.js"></script>
+      </head>`);
     }
   };
 }

package/dist/vite-plugin.mjs

@@ -1,70 +1,7 @@
 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;
+  viteAutoColorPlugin,
+  vite_plugin_default
+} from "./chunk-NJGGDAAU.mjs";
 export {
   vite_plugin_default as default,
   viteAutoColorPlugin

package/package.json

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

package/src/index.ts

@@ -1,5 +1,6 @@
 import { getTextHash } from './core/hash';
 import { ColorConfig, ColorGenerator } from './core/color';
+import { viteAutoColorPlugin } from './vite-plugin';
 
 // Precomputed colors cache (filled by Vite plugin at build time)
 const precomputedColors: Record<string, Record<string, string>> = {};
@@ -53,3 +54,6 @@ export function __internal__setPrecomputedColors(colors: Record<string, Record<s
 
 // Export types
 export type { ColorConfig };
+
+// Export Vite plugin
+export { viteAutoColorPlugin };

package/src/vite-plugin.ts

@@ -76,13 +76,13 @@ export function viteAutoColorPlugin(): Plugin {
         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";`
-      });
+    // Inject precomputed colors into HTML
+    transformIndexHtml(html) {
+      return html.replace('</head>', `
+        <script type="module" src="/v-auto-color-precomputed.js"></script>
+      </head>`);
     }
   };
 }