v-auto-color 1.0.4 → 1.0.5

package/dist/chunk-6X3GUPCU.mjs

@@ -0,0 +1,142 @@
+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);
+  }
+};
+
+// 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.js

@@ -93,9 +93,22 @@ var ColorGenerator = class {
 };
 
 // src/vite-plugin.ts
-var import_pluginutils = require("@rollup/pluginutils");
+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 = (0, import_pluginutils.createFilter)(["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx", "**/*.vue"]);
+  const filter = createFilter(["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx", "**/*.vue"]);
   return {
     name: "v-auto-color",
     // Analyze code during build and inject precomputed colors

package/dist/index.mjs

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

package/dist/vite-plugin.js

@@ -26,7 +26,6 @@ __export(vite_plugin_exports, {
   viteAutoColorPlugin: () => viteAutoColorPlugin
 });
 module.exports = __toCommonJS(vite_plugin_exports);
-var import_pluginutils = require("@rollup/pluginutils");
 
 // src/core/hash.ts
 function murmurHash3(text) {
@@ -92,8 +91,22 @@ var ColorGenerator = class {
 };
 
 // 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 = (0, import_pluginutils.createFilter)(["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx", "**/*.vue"]);
+  const filter = createFilter(["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx", "**/*.vue"]);
   return {
     name: "v-auto-color",
     // Analyze code during build and inject precomputed colors

package/dist/vite-plugin.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "v-auto-color",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Vite plugin for automatic color generation based on text similarity",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -32,7 +32,6 @@
     "vite": "^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
   },
   "dependencies": {
-    "@rollup/pluginutils": "^5.0.2"
   },
   "devDependencies": {
     "@types/node": "^18.19.3",

package/src/vite-plugin.ts

@@ -1,8 +1,27 @@
 import { Plugin } from 'vite';
-import { createFilter } from '@rollup/pluginutils';
 import { getTextHash } from './core/hash';
 import { ColorGenerator } from './core/color';
 
+// Simple file filter implementation (replaces @rollup/pluginutils createFilter)
+function createFilter(include: string[], exclude?: string[]) {
+  return function(id: string) {
+    // Check if id matches any include pattern
+    const included = include.some(pattern => {
+      if (pattern === '**/*') return true;
+      const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+      return regex.test(id);
+    });
+
+    // Check if id matches any exclude pattern
+    const excluded = exclude && exclude.some(pattern => {
+      const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+      return regex.test(id);
+    });
+
+    return included && !excluded;
+  };
+}
+
 // Vite plugin for precomputing colors at build time
 export function viteAutoColorPlugin(): Plugin {
   const filter = createFilter(['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', '**/*.vue']);