v-auto-color 1.0.3 → 1.0.4

package/dist/chunk-465SVM6G.mjs

@@ -0,0 +1,131 @@
+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"]);
+  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.js

@@ -96,12 +96,12 @@ var ColorGenerator = class {
 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
+    // 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;
@@ -122,6 +122,7 @@ function viteAutoColorPlugin() {
       while ((match = getColorRegex.exec(code)) !== null) {
         texts.add(match[1]);
       }
+      const colorUsage = {};
       colorSets.forEach((category) => {
         if (!colorUsage[category]) {
           colorUsage[category] = {};
@@ -132,25 +133,15 @@ function viteAutoColorPlugin() {
           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>`);
+      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;
     }
   };
 }

package/dist/index.mjs

@@ -3,7 +3,7 @@ import {
   __publicField,
   getTextHash,
   viteAutoColorPlugin
-} from "./chunk-NJGGDAAU.mjs";
+} from "./chunk-465SVM6G.mjs";
 
 // src/index.ts
 var precomputedColors = {};

package/dist/vite-plugin.js

@@ -94,12 +94,12 @@ var ColorGenerator = class {
 // 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
+    // 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;
@@ -120,6 +120,7 @@ function viteAutoColorPlugin() {
       while ((match = getColorRegex.exec(code)) !== null) {
         texts.add(match[1]);
       }
+      const colorUsage = {};
       colorSets.forEach((category) => {
         if (!colorUsage[category]) {
           colorUsage[category] = {};
@@ -130,25 +131,15 @@ function viteAutoColorPlugin() {
           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>`);
+      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;
     }
   };
 }

package/dist/vite-plugin.mjs

@@ -1,7 +1,7 @@
 import {
   viteAutoColorPlugin,
   vite_plugin_default
-} from "./chunk-NJGGDAAU.mjs";
+} from "./chunk-465SVM6G.mjs";
 export {
   vite_plugin_default as default,
   viteAutoColorPlugin

package/package.json

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

package/src/vite-plugin.ts

@@ -6,17 +6,17 @@ 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
+    // Analyze code during build and inject precomputed colors
     transform(code, id) {
       if (!filter(id)) return null;
 
+      // Check if this file imports useAutoColor
+      if (!code.includes('useAutoColor')) return null;
+
       // Extract useAutoColor calls and getColor calls
       const useAutoColorRegex = /useAutoColor\s*\(\s*(?:(['"])([^'"]+)\1|\{[^}]*\})\s*\)/g;
       const getColorRegex = /\.getColor\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
@@ -47,6 +47,7 @@ export function viteAutoColorPlugin(): Plugin {
       }
 
       // Precompute colors for extracted texts
+      const colorUsage: Record<string, Record<string, string>> = {};
       colorSets.forEach(category => {
         if (!colorUsage[category]) {
           colorUsage[category] = {};
@@ -59,30 +60,19 @@ export function viteAutoColorPlugin(): Plugin {
         });
       });
 
-      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)});
-      `;
+      // Inject precomputed colors into the code
+      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)});
+        `;
 
-      // Add precomputed colors module to bundle
-      this.emitFile({
-        type: 'asset',
-        fileName: 'v-auto-color-precomputed.js',
-        source: precomputedCode
-      });
-    },
+        // Add the precomputed code at the top of the file
+        code = precomputedCode + '\n' + code;
+      }
 
-    // Inject precomputed colors into HTML
-    transformIndexHtml(html) {
-      return html.replace('</head>', `
-        <script type="module" src="/v-auto-color-precomputed.js"></script>
-      </head>`);
+      return code;
     }
   };
 }