@aippy/vite-plugins 0.2.1 → 0.2.4

package/dist/aippy-preload/html-utils.d.ts

@@ -0,0 +1,26 @@
+/**
+ * HTML processing utilities for aippy preload plugin
+ */
+/**
+ * Generate meta tags for asset preloading
+ * @param assets - Array of asset URLs
+ * @returns HTML meta tags string
+ */
+export declare function generateMetaTags(assets: string[]): string;
+/**
+ * Inject meta tags into HTML content
+ * @param htmlContent - Original HTML content
+ * @param metaTags - Meta tags to inject
+ * @returns Modified HTML content
+ */
+export declare function injectMetaTags(htmlContent: string, metaTags: string): string;
+/**
+ * Log scan results to console
+ * @param assets - Array of found assets
+ */
+export declare function logScanResults(assets: string[]): void;
+/**
+ * Log injection result to console
+ * @param count - Number of meta tags injected
+ */
+export declare function logInjectionResult(count: number): void;

package/dist/aippy-preload/index.d.ts

@@ -1,12 +1,12 @@
 import { Plugin } from 'vite';
-interface AssetPreloadOptions {
-    extensions?: string[];
-    includeFiles?: string[];
-    exclude?: string[];
-    outDir?: string;
-    includeSubdirs?: boolean;
-    deepScan?: boolean;
-    srcDir?: string;
-}
+import { AssetPreloadOptions } from './types';
+/**
+ * Aippy preload plugin - scans source files for assets and injects preload meta tags
+ *
+ * This plugin scans source files (not build output) to avoid including third-party libraries
+ *
+ * @param options - Plugin options
+ * @returns Vite plugin
+ */
 export declare function aippyPreloadPlugin(options?: AssetPreloadOptions): Plugin;
 export default aippyPreloadPlugin;

package/dist/aippy-preload/index.js

@@ -1,147 +1,123 @@
-var f = Object.defineProperty;
-var g = (e, s, t) => s in e ? f(e, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[s] = t;
-var p = (e, s, t) => g(e, typeof s != "symbol" ? s + "" : s, t);
-import r from "fs/promises";
-import a from "path";
-import { glob as l } from "glob";
-import { extractAssetsFromContent as c } from "../utils/index.js";
-class F {
-  constructor(s = {}) {
-    p(this, "options");
-    this.options = {
-      extensions: [".js", ".css", ".png", ".jpg", ".jpeg", ".gif", ".svg", ".woff", ".woff2", ".ttf", ".eot"],
-      includeFiles: [],
-      exclude: ["*.map"],
-      outDir: "dist",
-      includeSubdirs: !0,
-      deepScan: !0,
-      srcDir: "src",
-      ...s
-    };
-  }
-  /**
-   * Scan external file resources
-   */
-  async scanExternalFiles() {
-    const s = [], t = this.options.extensions.map(
-      (i) => this.options.includeSubdirs ? a.join(this.options.outDir, "**", `*${i}`) : a.join(this.options.outDir, `*${i}`)
-    ), n = await l(t, {
-      ignore: this.options.exclude,
-      absolute: !0
-    });
-    if (s.push(...n), this.options.includeFiles.length > 0) {
-      const i = this.options.includeFiles.map((h) => this.options.includeSubdirs ? a.join(this.options.outDir, "**", h) : a.join(this.options.outDir, h)), u = await l(i, {
-        ignore: this.options.exclude,
-        absolute: !0
-      });
-      s.push(...u);
+import { promises as i } from "fs";
+import u from "path";
+import { extractAssetsFromContent as r } from "../utils/index.js";
+import { g as l } from "../file-scanner-DHkDSQm8.js";
+async function d(s) {
+  const t = [], n = [u.join(process.cwd(), "index.html")];
+  for (const c of n)
+    try {
+      const e = await i.readFile(c, "utf-8"), o = r(e, "html", s);
+      t.push(...o);
+    } catch {
+      console.warn("⚠️  No index.html found in project root");
     }
-    return [...new Set(s)].map((i) => `/${a.relative(this.options.outDir, i).replace(/\\/g, "/")}`);
-  }
-  /**
-   * Scan HTML files
-   */
-  async scanHtmlFiles() {
-    const s = [], t = await l("**/*.html", { cwd: this.options.outDir, absolute: !0 });
-    for (const n of t)
-      try {
-        const o = await r.readFile(n, "utf-8"), i = c(o, "html", this.options.extensions);
-        s.push(...i);
-      } catch (o) {
-        console.warn(`⚠️  Failed to read HTML file: ${n}`, o);
-      }
-    return s;
-  }
-  /**
-   * Scan JS files
-   */
-  async scanJsFiles() {
-    const s = [], t = await l("**/*.js", { cwd: this.options.outDir, absolute: !0 });
-    for (const n of t)
-      try {
-        const o = await r.readFile(n, "utf-8"), i = c(o, "js", this.options.extensions);
-        s.push(...i);
-      } catch (o) {
-        console.warn(`⚠️  Failed to read JS file: ${n}`, o);
-      }
-    return s;
-  }
-  /**
-   * Scan CSS files
-   */
-  async scanCssFiles() {
-    const s = [], t = await l("**/*.css", { cwd: this.options.outDir, absolute: !0 });
-    for (const n of t)
-      try {
-        const o = await r.readFile(n, "utf-8"), i = c(o, "css", this.options.extensions);
-        s.push(...i);
-      } catch (o) {
-        console.warn(`⚠️  Failed to read CSS file: ${n}`, o);
-      }
-    return s;
-  }
-  /**
-   * Execute complete asset scanning
-   */
-  async scanAllAssets() {
-    console.log("🔍 Scanning for static assets...");
-    const s = [], t = await this.scanExternalFiles();
-    if (s.push(...t), this.options.deepScan) {
-      console.log("🔍 Deep scanning file contents...");
-      const [n, o, i] = await Promise.all([
-        this.scanHtmlFiles(),
-        this.scanJsFiles(),
-        this.scanCssFiles()
-      ]);
-      s.push(...n, ...o, ...i);
+  return t;
+}
+async function g(s, t) {
+  const n = [], c = await l(s, [".ts", ".tsx", ".js", ".jsx"]);
+  for (const e of c)
+    try {
+      const o = await i.readFile(e, "utf-8"), a = r(o, "js", t);
+      n.push(...a);
+    } catch (o) {
+      console.warn(`⚠️  Failed to read JS file: ${e}`, o);
+    }
+  return n;
+}
+async function h(s, t) {
+  const n = [], c = await l(s, [".css", ".scss", ".sass", ".less"]);
+  for (const e of c)
+    try {
+      const o = await i.readFile(e, "utf-8"), a = r(o, "css", t);
+      n.push(...a);
+    } catch (o) {
+      console.warn(`⚠️  Failed to read CSS file: ${e}`, o);
     }
-    return [...new Set(s)];
+  return n;
+}
+async function m(s, t) {
+  const n = [], c = await l(s, [".json"]);
+  for (const e of c)
+    try {
+      const o = await i.readFile(e, "utf-8"), a = r(o, "js", t);
+      n.push(...a);
+    } catch (o) {
+      console.warn(`⚠️  Failed to read JSON file: ${e}`, o);
+    }
+  return n;
+}
+async function j(s, t, n) {
+  console.log("🔍 Scanning source files for static assets...");
+  const c = [];
+  if (n) {
+    console.log("🔍 Deep scanning source file contents...");
+    const [e, o, a, p] = await Promise.all([
+      d(t),
+      g(s, t),
+      h(s, t),
+      m(s, t)
+    ]);
+    c.push(...e, ...o, ...a, ...p);
   }
+  return [...new Set(c)];
 }
-function m(e) {
-  return e.map((s) => `    <meta content="${s}" name="aippy:preload">`).join(`
+const f = "<head>", F = f.length;
+function w(s) {
+  return s.map((t) => `    <meta content="${t}" name="aippy:preload">`).join(`
 `);
 }
-const d = "<head>", w = d.length;
-function j(e, s) {
-  const t = e.indexOf(d);
-  if (t === -1)
+function y(s, t) {
+  const n = s.indexOf(f);
+  if (n === -1)
     throw new Error("Could not find <head> tag in HTML");
-  const n = t + w;
-  return e.slice(0, n) + `
-` + s + `
-` + e.slice(n);
+  const c = n + F;
+  return s.slice(0, c) + `
+` + t + `
+` + s.slice(c);
 }
-function x(e) {
-  if (console.log(`📁 Found ${e.length} static assets`), e.length === 0) {
-    console.log("⚠️  No static assets found. This might be because all assets are inlined.");
+function A(s) {
+  if (console.log(`📁 Found ${s.length} static assets in source files`), s.length === 0) {
+    console.log("⚠️  No static assets found in source files.");
     return;
   }
-  console.log("📋 Assets found:"), e.forEach((s) => console.log(`   - ${s}`));
+  console.log("📋 Assets found:"), s.forEach((t) => console.log(`   - ${t}`));
 }
-function A(e) {
-  console.log(`✅ Injected ${e} preload meta tags into index.html`);
+function x(s) {
+  console.log(`✅ Injected ${s} preload meta tags into index.html`);
 }
-function P(e = {}) {
+function C(s = {}) {
+  const t = {
+    extensions: [".png", ".jpg", ".jpeg", ".gif", ".svg", ".mp4", ".mp3", ".wav", ".ogg", ".webm"],
+    srcDir: "src",
+    outDir: "dist",
+    deepScan: !0,
+    ...s
+  };
   return {
     name: "vite-plugin-aippy-preload",
     apply: "build",
+    // Ensure this plugin runs after other plugins (like viteSingleFile)
+    enforce: "post",
     async closeBundle() {
       try {
-        const t = await new F(e).scanAllAssets();
-        if (x(t), t.length === 0)
+        const n = await j(
+          t.srcDir,
+          t.extensions,
+          t.deepScan
+        );
+        if (A(n), n.length === 0)
           return;
-        const n = a.join(e.outDir || "dist", "index.html");
-        let o = await r.readFile(n, "utf-8");
-        const i = m(t);
-        o = j(o, i), await r.writeFile(n, o, "utf-8"), A(t.length);
-      } catch (s) {
-        console.error("❌ Error in asset preload plugin:", s);
+        const c = u.join(t.outDir, "index.html");
+        let e = await i.readFile(c, "utf-8");
+        const o = w(n);
+        e = y(e, o), await i.writeFile(c, e, "utf-8"), x(n.length);
+      } catch (n) {
+        console.error("❌ Error in aippy preload plugin:", n);
       }
     }
   };
 }
 export {
-  P as aippyPreloadPlugin,
-  P as default
+  C as aippyPreloadPlugin,
+  C as default
 };

package/dist/aippy-preload/scanner-utils.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Source file scanning utilities for aippy preload plugin
+ */
+/**
+ * Scan HTML files in project root directory
+ * @param extensions - Asset extensions to look for
+ * @returns Array of asset URLs
+ */
+export declare function scanHtmlFiles(extensions: string[]): Promise<string[]>;
+/**
+ * Scan TypeScript/JavaScript files in source directory
+ * @param srcDir - Source directory
+ * @param extensions - Asset extensions to look for
+ * @returns Array of asset URLs
+ */
+export declare function scanJsFiles(srcDir: string, extensions: string[]): Promise<string[]>;
+/**
+ * Scan CSS files in source directory
+ * @param srcDir - Source directory
+ * @param extensions - Asset extensions to look for
+ * @returns Array of asset URLs
+ */
+export declare function scanCssFiles(srcDir: string, extensions: string[]): Promise<string[]>;
+/**
+ * Scan JSON files in source directory for asset URLs
+ * @param srcDir - Source directory
+ * @param extensions - Asset extensions to look for
+ * @returns Array of asset URLs
+ */
+export declare function scanJsonFiles(srcDir: string, extensions: string[]): Promise<string[]>;
+/**
+ * Scan all source files for asset references
+ * @param srcDir - Source directory
+ * @param extensions - Asset extensions to look for
+ * @param deepScan - Whether to deep scan file contents
+ * @returns Array of unique asset URLs
+ */
+export declare function scanAllSourceAssets(srcDir: string, extensions: string[], deepScan: boolean): Promise<string[]>;

package/dist/aippy-preload/types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Type definitions for aippy preload plugin
+ */
+export interface AssetPreloadOptions {
+    extensions?: string[];
+    srcDir?: string;
+    outDir?: string;
+    deepScan?: boolean;
+}

package/dist/asset-constants/generator-utils.d.ts

@@ -0,0 +1,22 @@
+import { AssetInfo } from './types';
+/**
+ * Generate assets.json file content from asset info
+ * @param assets - Map of assets
+ * @param existingAssets - Map of existing assets from previous runs
+ * @returns JSON string
+ */
+export declare function generateAssetsFileContent(assets: Map<string, AssetInfo>, existingAssets: Map<string, string>): string;
+/**
+ * Parse existing assets.json file
+ * @param content - File content
+ * @returns Map of URI to constant name
+ */
+export declare function parseExistingAssetsContent(content: string): Map<string, string>;
+/**
+ * Log generation statistics
+ * @param totalAssets - Total number of assets
+ * @param existingAssets - Map of existing assets
+ * @param assets - Map of current assets
+ * @param outputFile - Output file path
+ */
+export declare function logGenerationStats(totalAssets: number, existingAssets: Map<string, string>, assets: Map<string, AssetInfo>, outputFile: string): void;

package/dist/asset-constants/index.d.ts

@@ -1,9 +1,4 @@
 import { Plugin } from 'vite';
-interface AssetConstantsOptions {
-    extensions?: string[];
-    srcDir?: string;
-    outputFile?: string;
-    devMode?: boolean;
-}
+import { AssetConstantsOptions } from './types';
 export declare function assetConstantsPlugin(options?: AssetConstantsOptions): Plugin;
 export default assetConstantsPlugin;

package/dist/asset-constants/index.js

@@ -1,19 +1,50 @@
-var v = Object.defineProperty;
-var $ = (l, s, t) => s in l ? v(l, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : l[s] = t;
-var g = (l, s, t) => $(l, typeof s != "symbol" ? s + "" : s, t);
-import { promises as f } from "fs";
-import p from "path";
-import { parse as F } from "@babel/parser";
-import d from "@babel/traverse";
+var C = Object.defineProperty;
+var v = (a, s, t) => s in a ? C(a, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[s] = t;
+var f = (a, s, t) => v(a, typeof s != "symbol" ? s + "" : s, t);
+import { promises as g } from "fs";
+import d from "path";
+import { parse as N } from "@babel/parser";
+import h from "@babel/traverse";
 import * as u from "@babel/types";
 import m from "@babel/generator";
-import { generateConstantName as j, extractAssetsFromContent as N, processAssetURL as C } from "../utils/index.js";
-const A = typeof d == "function" ? d : d.default, U = typeof m == "function" ? m : m.default;
-class E {
+import { generateConstantName as U, extractAssetsFromContent as $, processAssetURL as j } from "../utils/index.js";
+import { F as E, g as A, a as b } from "../file-scanner-DHkDSQm8.js";
+function D(a, s) {
+  const t = {};
+  for (const [i, o] of s.entries())
+    t[o] = i;
+  return Array.from(a.values()).forEach((i) => {
+    t[i.constantName] = i.originalUri;
+  }), JSON.stringify(t, null, 2) + `
+`;
+}
+function I(a) {
+  const s = /* @__PURE__ */ new Map();
+  try {
+    if (!a.trim())
+      return s;
+    const t = JSON.parse(a);
+    for (const [e, i] of Object.entries(t))
+      typeof i == "string" && s.set(i, e);
+    s.size > 0 && console.log(`📋 Found ${s.size} existing constants in assets.json`);
+  } catch (t) {
+    console.warn("Warning: Failed to parse existing assets.json:", t);
+  }
+  return s;
+}
+function S(a, s, t, e) {
+  const i = Array.from(t.values()).filter(
+    (n) => s.has(n.originalUri)
+  ).length, o = a - i;
+  o > 0 ? console.log(`✅ Generated ${a} asset constants (${o} new, ${i} reused) in ${e}`) : a > 0 ? console.log(`✅ Generated ${a} asset constants (all reused from existing) in ${e}`) : console.log("✅ No asset constants found");
+}
+const x = typeof h == "function" ? h : h.default, W = typeof m == "function" ? m : m.default;
+class R {
   constructor(s = {}) {
-    g(this, "options");
-    g(this, "assets", /* @__PURE__ */ new Map());
-    g(this, "existingAssets", /* @__PURE__ */ new Map());
+    f(this, "options");
+    f(this, "assets", /* @__PURE__ */ new Map());
+    f(this, "existingAssets", /* @__PURE__ */ new Map());
+    f(this, "fileCache", new E());
     this.options = {
       extensions: [".png", ".jpg", ".jpeg", ".gif", ".svg", ".mp4", ".mp3", ".wav", ".ogg", ".webm"],
       srcDir: "src",
@@ -22,157 +53,115 @@ class E {
       ...s
     };
   }
+  clearCache() {
+    this.fileCache.clear();
+  }
   generateConstantName(s) {
     const t = /* @__PURE__ */ new Set([
       ...Array.from(this.assets.values()).map((e) => e.constantName),
       ...Array.from(this.existingAssets.values())
     ]);
-    return j(s, t);
+    return U(s, t);
   }
   async scanTsFile(s) {
     try {
-      const t = await f.readFile(s, "utf-8");
-      F(t, {
-        sourceType: "module",
-        plugins: ["typescript", "jsx", "decorators-legacy"]
-      });
-      const e = [];
-      return N(t, "js", this.options.extensions).forEach((i) => {
-        const n = this.generateConstantName(i), a = t.split(`
-`).findIndex((h) => h.includes(i)) + 1;
+      const t = await this.fileCache.read(s), e = [], i = $(t, "js", this.options.extensions), o = t.split(`
+`);
+      return i.forEach((n) => {
+        const r = this.generateConstantName(n), c = o.findIndex((p) => p.includes(n)) + 1;
         e.push({
-          originalUri: i,
-          constantName: n,
+          originalUri: n,
+          constantName: r,
           filePath: s,
-          line: a,
+          line: c,
           column: 1
         });
       }), e;
     } catch (t) {
-      return console.warn(`Warning: Failed to parse ${s}:`, t), [];
+      return console.warn(`Warning: Failed to scan ${s}:`, t), [];
     }
   }
   async scanAllTsFiles() {
     const s = this.options.srcDir;
     try {
-      const t = await this.getAllTsFiles(s);
+      const t = await A(s, [".ts", ".tsx"]);
       for (const e of t) {
         if (e.endsWith("assets.json") || e.endsWith("assets.ts"))
           continue;
-        (await this.scanTsFile(e)).forEach((i) => {
-          this.existingAssets.has(i.originalUri) && (i.constantName = this.existingAssets.get(i.originalUri));
-          const n = i.originalUri;
-          this.assets.has(n) || this.assets.set(n, i);
+        (await this.scanTsFile(e)).forEach((o) => {
+          this.existingAssets.has(o.originalUri) && (o.constantName = this.existingAssets.get(o.originalUri));
+          const n = o.originalUri;
+          this.assets.has(n) || this.assets.set(n, o);
         });
       }
     } catch (t) {
       console.error("Error scanning TypeScript files:", t);
     }
   }
-  async getAllTsFiles(s) {
-    const t = [];
-    try {
-      const e = await f.readdir(s, { withFileTypes: !0 });
-      for (const o of e) {
-        const i = p.join(s, o.name);
-        if (o.isDirectory()) {
-          const n = await this.getAllTsFiles(i);
-          t.push(...n);
-        } else o.isFile() && /\.(ts|tsx)$/.test(o.name) && t.push(i);
-      }
-    } catch (e) {
-      console.warn(`Warning: Failed to read directory ${s}:`, e);
-    }
-    return t;
-  }
-  generateAssetsFileContent() {
-    const s = Array.from(this.assets.values()), t = {};
-    return s.forEach((e) => {
-      t[e.constantName] = e.originalUri;
-    }), JSON.stringify(t, null, 2) + `
-`;
-  }
   async readExistingAssetsFile() {
     try {
-      return await f.readFile(this.options.outputFile, "utf-8");
+      return await g.readFile(this.options.outputFile, "utf-8");
     } catch {
       return "";
     }
   }
   async parseExistingAssets() {
-    try {
-      const s = await this.readExistingAssetsFile();
-      if (!s.trim())
-        return;
-      const t = JSON.parse(s);
-      for (const [e, o] of Object.entries(t))
-        typeof o == "string" && this.existingAssets.set(o, e);
-      this.existingAssets.size > 0 && console.log(`📋 Found ${this.existingAssets.size} existing constants in assets.json`);
-    } catch (s) {
-      console.warn("Warning: Failed to parse existing assets.json:", s);
-    }
+    const s = await this.readExistingAssetsFile();
+    this.existingAssets = I(s);
   }
   async generateAssetsFile() {
     await this.parseExistingAssets(), await this.scanAllTsFiles();
-    const s = this.generateAssetsFileContent(), t = p.dirname(this.options.outputFile);
-    await f.mkdir(t, { recursive: !0 }), await f.writeFile(this.options.outputFile, s, "utf-8");
-    const e = Array.from(this.assets.values()).filter(
-      (i) => this.existingAssets.has(i.originalUri)
-    ).length, o = this.assets.size - e;
-    o > 0 ? console.log(`✅ Generated ${this.assets.size} asset constants (${o} new, ${e} reused) in ${this.options.outputFile}`) : this.assets.size > 0 ? console.log(`✅ Generated ${this.assets.size} asset constants (all reused from existing) in ${this.options.outputFile}`) : console.log("✅ No asset constants found");
+    const s = D(this.assets, this.existingAssets), t = d.dirname(this.options.outputFile);
+    await g.mkdir(t, { recursive: !0 }), await g.writeFile(this.options.outputFile, s, "utf-8"), S(this.assets.size, this.existingAssets, this.assets, this.options.outputFile);
   }
   getAssets() {
     return Array.from(this.assets.values());
   }
   async replaceUrisInFile(s, t) {
     try {
-      const e = await f.readFile(s, "utf-8"), o = F(e, {
+      const e = await this.fileCache.read(s), i = N(e, {
         sourceType: "module",
         plugins: ["typescript", "jsx", "decorators-legacy"]
       });
-      let i = !1;
-      if (A(o, {
+      let o = !1;
+      if (x(i, {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        StringLiteral: (c) => {
-          const h = c.node.value, w = C(h);
+        StringLiteral: (l) => {
+          const p = l.node.value, w = j(p);
           if (t.has(w)) {
-            const x = t.get(w), y = u.memberExpression(
+            const F = t.get(w), y = u.memberExpression(
               u.identifier("assetsData"),
-              u.identifier(x)
+              u.identifier(F)
             );
-            c.parent && u.isJSXAttribute(c.parent) ? c.replaceWith(u.jsxExpressionContainer(y)) : c.replaceWith(y), i = !0;
+            l.parent && u.isJSXAttribute(l.parent) ? l.replaceWith(u.jsxExpressionContainer(y)) : l.replaceWith(y), o = !0;
           }
         }
-      }), !i)
+      }), !o)
         return;
-      const n = this.getRelativeImportPath(s, this.options.outputFile) + ".json";
+      const n = b(s, this.options.outputFile) + ".json";
       let r = !1;
-      if (A(o, {
+      if (x(i, {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        ImportDeclaration: (c) => {
-          c.node.source.value === n && (r = !0, c.stop());
+        ImportDeclaration: (l) => {
+          l.node.source.value === n && (r = !0, l.stop());
         }
       }), !r) {
-        const c = u.importDeclaration(
+        const l = u.importDeclaration(
           [u.importDefaultSpecifier(u.identifier("assetsData"))],
           u.stringLiteral(n)
         );
-        o.program.body.unshift(c);
+        i.program.body.unshift(l);
       }
-      const a = U(o, {
+      const c = W(i, {
         retainLines: !1,
         comments: !0,
         compact: !1
       }, e);
-      await f.writeFile(s, a.code, "utf-8"), console.log(`  ✓ Replaced URIs in ${p.relative(process.cwd(), s)}`);
+      await g.writeFile(s, c.code, "utf-8"), this.fileCache.invalidate(s), console.log(`  ✓ Replaced URIs in ${d.relative(process.cwd(), s)}`);
     } catch (e) {
       console.warn(`Warning: Failed to replace URIs in ${s}:`, e);
     }
   }
-  getRelativeImportPath(s, t) {
-    const o = p.relative(p.dirname(s), t).replace(/\.(ts|json)$/, "");
-    return o.startsWith(".") ? o : `./${o}`;
-  }
   async replaceAllUris() {
     const s = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Set();
     for (const e of this.assets.values())
@@ -188,35 +177,35 @@ class E {
       const t = /* @__PURE__ */ new Map();
       try {
         const n = JSON.parse(s);
-        for (const [r, a] of Object.entries(n))
-          typeof a == "string" && t.set(r, a);
+        for (const [r, c] of Object.entries(n))
+          typeof c == "string" && t.set(r, c);
       } catch (n) {
         console.warn("Warning: Failed to parse assets.json:", n);
         return;
       }
       if (t.size === 0)
         return;
-      const e = /* @__PURE__ */ new Set(), o = await this.getAllTsFiles(this.options.srcDir);
-      for (const n of o)
+      const e = /* @__PURE__ */ new Set(), i = await A(this.options.srcDir, [".ts", ".tsx"]);
+      for (const n of i)
         if (!(n.endsWith("assets.json") || n.endsWith("assets.ts")))
           try {
-            const r = await f.readFile(n, "utf-8");
-            for (const a of t.keys())
-              r.includes(a) && e.add(a);
+            const r = await this.fileCache.read(n);
+            for (const c of t.keys())
+              r.includes(c) && e.add(c);
           } catch (r) {
             console.warn(`Warning: Failed to read ${n}:`, r);
           }
-      const i = [];
+      const o = [];
       for (const n of t.keys())
-        e.has(n) || i.push(n);
-      if (i.length > 0) {
-        console.log(`🧹 Removing ${i.length} unused constant(s):`), i.forEach((r) => {
+        e.has(n) || o.push(n);
+      if (o.length > 0) {
+        console.log(`🧹 Removing ${o.length} unused constant(s):`), o.forEach((r) => {
           console.log(`  - ${r}`);
         });
         const n = [];
-        for (const r of i) {
-          const a = t.get(r);
-          a && n.push(a);
+        for (const r of o) {
+          const c = t.get(r);
+          c && n.push(c);
         }
         for (const r of n)
           this.assets.delete(r);
@@ -227,22 +216,24 @@ class E {
     }
   }
 }
-function z(l = {}) {
+function q(a = {}) {
   return {
     name: "vite-plugin-asset-constants",
     apply: "build",
+    // Ensure this plugin runs before other plugins to modify source files before build
+    enforce: "pre",
     async buildStart() {
-      if (l.devMode)
+      if (a.devMode)
         try {
-          const s = new E(l);
+          const s = new R(a);
           await s.generateAssetsFile();
           const t = s.getAssets();
           t.length > 0 && (console.log(`📦 Found ${t.length} asset references:`), t.forEach((e) => {
-            console.log(`  ${e.constantName} = '${e.originalUri}' (${p.relative(process.cwd(), e.filePath)}:${e.line})`);
+            console.log(`  ${e.constantName} = '${e.originalUri}' (${d.relative(process.cwd(), e.filePath)}:${e.line})`);
           }), console.log(`
 🔄 Replacing URIs with constants...`), await s.replaceAllUris(), console.log("✅ URI replacement completed!")), console.log(`
 🧹 Checking for unused constants...`), await s.cleanupUnusedConstants(), await s.generateAssetsFile(), console.log(`✅ Asset constants finalized!
-`);
+`), s.clearCache();
         } catch (s) {
           console.error("❌ Error in asset constants plugin:", s);
         }
@@ -250,6 +241,6 @@ function z(l = {}) {
   };
 }
 export {
-  z as assetConstantsPlugin,
-  z as default
+  q as assetConstantsPlugin,
+  q as default
 };

package/dist/asset-constants/types.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Type definitions for asset constants plugin
+ */
+export interface AssetConstantsOptions {
+    extensions?: string[];
+    srcDir?: string;
+    outputFile?: string;
+    devMode?: boolean;
+}
+export interface AssetInfo {
+    originalUri: string;
+    constantName: string;
+    filePath: string;
+    line: number;
+    column: number;
+}

package/dist/file-scanner-DHkDSQm8.js

@@ -0,0 +1,50 @@
+var l = Object.defineProperty;
+var u = (e, t, a) => t in e ? l(e, t, { enumerable: !0, configurable: !0, writable: !0, value: a }) : e[t] = a;
+var o = (e, t, a) => u(e, typeof t != "symbol" ? t + "" : t, a);
+import { promises as h } from "fs";
+import i from "path";
+async function f(e, t) {
+  const a = [];
+  try {
+    const s = await h.readdir(e, { withFileTypes: !0 });
+    for (const r of s) {
+      const c = i.join(e, r.name);
+      if (r.isDirectory()) {
+        const n = await f(c, t);
+        a.push(...n);
+      } else if (r.isFile()) {
+        const n = i.extname(r.name);
+        t.includes(n) && a.push(c);
+      }
+    }
+  } catch (s) {
+    console.warn(`Warning: Failed to read directory ${e}:`, s);
+  }
+  return a;
+}
+function y(e, t) {
+  const s = i.relative(i.dirname(e), t).replace(/\.(ts|tsx|js|jsx|json)$/, "");
+  return s.startsWith(".") ? s : `./${s}`;
+}
+class F {
+  constructor() {
+    o(this, "cache", /* @__PURE__ */ new Map());
+  }
+  async read(t) {
+    if (this.cache.has(t))
+      return this.cache.get(t);
+    const a = await h.readFile(t, "utf-8");
+    return this.cache.set(t, a), a;
+  }
+  invalidate(t) {
+    this.cache.delete(t);
+  }
+  clear() {
+    this.cache.clear();
+  }
+}
+export {
+  F,
+  y as a,
+  f as g
+};

package/dist/utils/file-scanner.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Common file scanning utilities for vite plugins
+ */
+/**
+ * Recursively get all files in a directory matching specified extensions
+ * @param dir - Directory to scan
+ * @param extensions - File extensions to match (e.g., ['.ts', '.tsx', '.js'])
+ * @returns Array of file paths
+ */
+export declare function getFilesByExtension(dir: string, extensions: string[]): Promise<string[]>;
+/**
+ * Get relative import path from one file to another
+ * @param fromFile - Source file path
+ * @param toFile - Target file path
+ * @returns Relative import path (without extension)
+ */
+export declare function getRelativeImportPath(fromFile: string, toFile: string): string;
+/**
+ * Read file with caching support
+ */
+export declare class FileContentCache {
+    private cache;
+    read(filePath: string): Promise<string>;
+    invalidate(filePath: string): void;
+    clear(): void;
+}

package/dist/utils/index.d.ts

@@ -3,8 +3,9 @@
  */
 /**
  * Process asset URL to ensure it's properly formatted
+ * Keep the original path format to preserve context-dependent paths
  * @param url - The asset URL to process
- * @returns Processed URL
+ * @returns Processed URL (trimmed and cleaned)
  */
 export declare function processAssetURL(url: string): string;
 /**

package/dist/utils/index.js

@@ -1,114 +1,96 @@
-import { existsSync as h } from "fs";
+import { existsSync as g } from "fs";
 import f from "path";
-const u = [".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp"], w = [".mp4", ".webm", ".mov", ".avi"], d = [".mp3", ".wav", ".ogg", ".m4a"];
-function g(e) {
-  return e.match(/^https?:\/\//) || e.match(/^data:/) || e.match(/^blob:/) || e.startsWith("/") ? e : `/${e.replace(/^(\.\.\/)+/, "").replace(/^\.\//, "")}`;
+const u = [".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp"], d = [".mp4", ".webm", ".mov", ".avi"], w = [".mp3", ".wav", ".ogg", ".m4a"];
+function m(t) {
+  return t = t.trim(), t.match(/^https?:\/\//) || t.match(/^data:/) || t.match(/^blob:/), t;
 }
-function p(e) {
-  if (!e || e.length < 4 || e.includes("node_modules") || e.startsWith("./") && e.length < 10)
+function h(t) {
+  if (!t || t.length < 4 || t.includes("node_modules") || t.startsWith("./") && t.length < 10)
     return !1;
-  let t;
-  if (e.match(/^https?:\/\//)) {
-    const n = e.split("/");
-    t = n[n.length - 1];
+  let e;
+  if (t.match(/^https?:\/\//)) {
+    const r = t.split("/");
+    e = r[r.length - 1];
   } else {
-    const n = e.split("/");
-    t = n[n.length - 1];
+    const r = t.split("/");
+    e = r[r.length - 1];
   }
-  if (t = t.split("?")[0].split("#")[0], !t || t.startsWith("."))
+  if (e = e.split("?")[0].split("#")[0], !e || e.startsWith("."))
     return !1;
-  const r = t.split(".");
-  return !(r.length < 2 || r[0].length === 0 || r[r.length - 1].toLowerCase() === "json");
+  const s = e.split(".");
+  return !(s.length < 2 || s[0].length === 0 || s[s.length - 1].toLowerCase() === "json");
 }
-function A(e, t = /* @__PURE__ */ new Set()) {
-  let r = "ASSET";
-  u.some((s) => e.endsWith(s)) ? r = "IMAGE" : w.some((s) => e.endsWith(s)) ? r = "VIDEO" : d.some((s) => e.endsWith(s)) && (r = "AUDIO");
+function C(t, e = /* @__PURE__ */ new Set()) {
+  let s = "ASSET";
+  u.some((n) => t.endsWith(n)) ? s = "IMAGE" : d.some((n) => t.endsWith(n)) ? s = "VIDEO" : w.some((n) => t.endsWith(n)) && (s = "AUDIO");
   let o;
-  const n = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const r = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   do {
-    let s = "";
-    for (let c = 0; c < 4; c++)
-      s += n[Math.floor(Math.random() * n.length)];
-    o = `${r}_${s}`;
-  } while (t.has(o));
+    let n = "";
+    for (let i = 0; i < 4; i++)
+      n += r[Math.floor(Math.random() * r.length)];
+    o = `${s}_${n}`;
+  } while (e.has(o));
   return o;
 }
-function E(e) {
-  return e.replace(
+function E(t) {
+  return t.replace(
     /(["'])(?:(?=(\\?))\2.)*?\1|\/\*[\s\S]*?\*\/|\/\/.*/g,
-    (r) => r.startsWith('"') || r.startsWith("'") ? r : ""
+    (s) => s.startsWith('"') || s.startsWith("'") ? s : ""
   );
 }
-function x(e) {
-  return e.replace(/\/\*[\s\S]*?\*\//g, "");
+function S(t) {
+  return t.replace(/\/\*[\s\S]*?\*\//g, "");
 }
-function S(e, t, r = [".js", ".css", ".png", ".jpg", ".jpeg", ".gif", ".svg", ".woff", ".woff2", ".ttf", ".eot"]) {
+function j(t, e, s = [".js", ".css", ".png", ".jpg", ".jpeg", ".gif", ".svg", ".woff", ".woff2", ".ttf", ".eot"]) {
   const o = /* @__PURE__ */ new Set();
-  let n = e;
-  t === "js" ? n = E(e) : t === "css" && (n = x(e));
-  const s = r.map((c) => c.replace(/^\./, "")).join("|");
-  if (t === "html")
+  let r = t;
+  e === "js" ? r = E(t) : e === "css" && (r = S(t));
+  const n = s.map((i) => i.replace(/^\./, "")).join("|");
+  if (e === "html")
     [
       // src/href attributes for img, script, link, video, audio tags
-      new RegExp(`(?:src|href)=["']([^"']*\\.(?:${s}))["']`, "g"),
+      new RegExp(`(?:src|href)=["']([^"']*\\.(?:${n}))["']`, "g"),
       // url() in CSS
-      new RegExp(`url\\(["']?([^"']*\\.(?:${s}))["']?\\)`, "g")
-    ].forEach((i) => {
-      let l;
-      for (; (l = i.exec(n)) !== null; )
-        l[1] && p(l[1]) && o.add(g(l[1]));
-    }), (n.match(/<script[^>]*>[\s\S]*?<\/script>/g) || []).forEach((i) => {
-      const l = i.replace(/<script[^>]*>/, "").replace(/<\/script>/, "");
-      S(l, "js", r).forEach((m) => o.add(m));
+      new RegExp(`url\\(["']?([^"']*\\.(?:${n}))["']?\\)`, "g")
+    ].forEach((l) => {
+      let a;
+      for (; (a = l.exec(r)) !== null; )
+        a[1] && h(a[1]) && o.add(m(a[1]));
+    }), (r.match(/<script[^>]*>[\s\S]*?<\/script>/g) || []).forEach((l) => {
+      const a = l.replace(/<script[^>]*>/, "").replace(/<\/script>/, "");
+      j(a, "js", s).forEach((p) => o.add(p));
     });
-  else if (t === "js")
-    [
-      // Dynamic import()
-      new RegExp(`import\\(["']([^"']*\\.(?:${s}))["']\\)`, "g"),
-      // fetch() requests
-      new RegExp(`fetch\\(["']([^"']*\\.(?:${s}))["']\\)`, "g"),
-      // new Image() creation
-      new RegExp(`new\\s+Image\\(\\)\\.src\\s*=\\s*["']([^"']*\\.(?:${s}))["']`, "g"),
-      // Direct src assignment
-      new RegExp(`\\.src\\s*=\\s*["']([^"']*\\.(?:${s}))["']`, "g"),
-      // Resource paths in variable assignments
-      new RegExp(`=\\s*["']([^"']*\\.(?:${s}))["']`, "g"),
-      // Resource paths in variable declarations
-      new RegExp(`const\\s+\\w+\\s*=\\s*["']([^"']*\\.(?:${s}))["']`, "g"),
-      // Variable assignments in minified code
-      new RegExp(`\\w+\\s*=\\s*["']([^"']*\\.(?:${s}))["']`, "g"),
-      // Resource paths in string literals (more precise matching)
-      new RegExp(`["']([^"']*\\.(?:${s}))["']`, "g")
-    ].forEach((a) => {
-      let i;
-      for (; (i = a.exec(n)) !== null; )
-        i[1] && p(i[1]) && o.add(g(i[1]));
-    });
-  else if (t === "css") {
-    const c = new RegExp(`url\\(["']?([^"']*\\.(?:${s}))["']?\\)`, "g");
-    let a;
-    for (; (a = c.exec(n)) !== null; )
-      a[1] && p(a[1]) && o.add(g(a[1]));
+  else if (e === "js") {
+    const i = new RegExp(`["']([^"']*\\.(?:${n}))["']`, "g");
+    let c;
+    for (; (c = i.exec(r)) !== null; )
+      c[1] && h(c[1]) && o.add(m(c[1]));
+  } else if (e === "css") {
+    const i = new RegExp(`url\\(["']?([^"']*\\.(?:${n}))["']?\\)`, "g");
+    let c;
+    for (; (c = i.exec(r)) !== null; )
+      c[1] && h(c[1]) && o.add(m(c[1]));
   }
   return Array.from(o);
 }
-function I(e = process.cwd()) {
+function N(t = process.cwd()) {
   try {
-    let t = e, r = 0;
-    for (; t !== f.parse(t).root && r < 20; ) {
-      if (h(f.join(t, "package.json")))
-        return t;
-      t = f.dirname(t), r++;
+    let e = t, s = 0;
+    for (; e !== f.parse(e).root && s < 20; ) {
+      if (g(f.join(e, "package.json")))
+        return e;
+      e = f.dirname(e), s++;
     }
     return process.cwd();
-  } catch (t) {
-    return console.error("Error finding project root:", t), process.cwd();
+  } catch (e) {
+    return console.error("Error finding project root:", e), process.cwd();
   }
 }
 export {
-  S as extractAssetsFromContent,
-  I as findProjectRoot,
-  A as generateConstantName,
-  p as isValidAsset,
-  g as processAssetURL
+  j as extractAssetsFromContent,
+  N as findProjectRoot,
+  C as generateConstantName,
+  h as isValidAsset,
+  m as processAssetURL
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aippy/vite-plugins",
-  "version": "0.2.1",
+  "version": "0.2.4",
   "description": "Vite plugins for Aippy projects - Asset management and component tagging",
   "private": false,
   "type": "module",