@aippy/vite-plugins 0.2.0

package/README.md

@@ -0,0 +1,102 @@
+# @aippy/vite-plugins
+
+Vite plugins collection for Aippy projects, providing asset management and component tagging capabilities.
+
+## Installation
+
+```bash
+pnpm add -D @aippy/vite-plugins
+```
+
+## Plugins
+
+### 1. Asset Constants Plugin
+
+Generates constant references for static assets and replaces hardcoded paths.
+
+```typescript
+import { assetConstantsPlugin } from '@aippy/vite-plugins/asset-constants'
+
+export default defineConfig({
+  plugins: [
+    assetConstantsPlugin({
+      extensions: ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.mp4', '.mp3'],
+      srcDir: 'src',
+      outputFile: 'src/config/assets.json',
+      devMode: true
+    })
+  ]
+})
+```
+
+### 2. Aippy Preload Plugin
+
+Scans build output and generates preload meta tags for assets.
+
+```typescript
+import { aippyPreloadPlugin } from '@aippy/vite-plugins/aippy-preload'
+
+export default defineConfig({
+  plugins: [
+    aippyPreloadPlugin({
+      extensions: ['.js', '.css', '.png', '.jpg', '.svg'],
+      outDir: 'dist',
+      includeSubdirs: true
+    })
+  ]
+})
+```
+
+### 3. Aippy Tagger Plugin
+
+Tags React components with metadata for development tools and inspector.
+
+```typescript
+import { aippyTaggerPlugin } from '@aippy/vite-plugins/aippy-tagger'
+
+export default defineConfig({
+  plugins: [
+    aippyTaggerPlugin()
+  ]
+})
+```
+
+### All-in-One Import
+
+```typescript
+import { assetConstantsPlugin, aippyPreloadPlugin, aippyTaggerPlugin } from '@aippy/vite-plugins'
+```
+
+### Utility Functions
+
+The package also exports utility functions that can be used independently:
+
+```typescript
+import { 
+  processAssetURL, 
+  isValidAsset, 
+  generateConstantName, 
+  extractAssetsFromContent,
+  findProjectRoot 
+} from '@aippy/vite-plugins/utils'
+
+// Process asset URLs
+const processedUrl = processAssetURL('./image.png') // '/image.png'
+
+// Validate asset paths
+const isValid = isValidAsset('./image.png') // true
+
+// Generate constant names
+const constantName = generateConstantName('/image.png') // 'IMAGE_ABCD'
+
+// Extract assets from content
+const assets = extractAssetsFromContent(htmlContent, 'html', ['.png', '.jpg'])
+
+// Find project root
+const projectRoot = findProjectRoot() // '/path/to/project'
+```
+
+## License
+
+UNLICENSED - Aippy Team
+

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

@@ -0,0 +1,11 @@
+import { Plugin } from 'vite';
+interface AssetPreloadOptions {
+    extensions?: string[];
+    includeFiles?: string[];
+    exclude?: string[];
+    outDir?: string;
+    includeSubdirs?: boolean;
+    deepScan?: boolean;
+}
+export declare function aippyPreloadPlugin(options?: AssetPreloadOptions): Plugin;
+export default aippyPreloadPlugin;

package/dist/aippy-preload/index.js

@@ -0,0 +1,146 @@
+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,
+      ...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);
+    }
+    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 [...new Set(s)];
+  }
+}
+function m(e) {
+  return e.map((s) => `    <meta content="${s}" name="aippy:preload">`).join(`
+`);
+}
+const d = "<head>", w = d.length;
+function j(e, s) {
+  const t = e.indexOf(d);
+  if (t === -1)
+    throw new Error("Could not find <head> tag in HTML");
+  const n = t + w;
+  return e.slice(0, n) + `
+` + s + `
+` + e.slice(n);
+}
+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.");
+    return;
+  }
+  console.log("📋 Assets found:"), e.forEach((s) => console.log(`   - ${s}`));
+}
+function A(e) {
+  console.log(`✅ Injected ${e} preload meta tags into index.html`);
+}
+function P(e = {}) {
+  return {
+    name: "vite-plugin-aippy-preload",
+    apply: "build",
+    async closeBundle() {
+      try {
+        const t = await new F(e).scanAllAssets();
+        if (x(t), t.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);
+      }
+    }
+  };
+}
+export {
+  P as aippyPreloadPlugin,
+  P as default
+};

package/dist/aippy-preload.d.ts

@@ -0,0 +1,6 @@
+export * from './aippy-preload/index'
+export {}
+import _default from './aippy-preload/index'
+export default _default
+export * from './aippy-preload/index'
+export {}

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

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

package/dist/aippy-tagger/index.js

@@ -0,0 +1,381 @@
+import { parse as E } from "@babel/parser";
+import * as A from "esbuild";
+import G from "fs/promises";
+import P from "magic-string";
+import i from "path";
+import { findProjectRoot as F } from "../utils/index.js";
+const H = [
+  "object3D",
+  "audioListener",
+  "positionalAudio",
+  "mesh",
+  "batchedMesh",
+  "instancedMesh",
+  "scene",
+  "sprite",
+  "lOD",
+  "skinnedMesh",
+  "skeleton",
+  "bone",
+  "lineSegments",
+  "lineLoop",
+  "points",
+  "group",
+  "camera",
+  "perspectiveCamera",
+  "orthographicCamera",
+  "cubeCamera",
+  "arrayCamera",
+  "instancedBufferGeometry",
+  "bufferGeometry",
+  "boxBufferGeometry",
+  "circleBufferGeometry",
+  "coneBufferGeometry",
+  "cylinderBufferGeometry",
+  "dodecahedronBufferGeometry",
+  "extrudeBufferGeometry",
+  "icosahedronBufferGeometry",
+  "latheBufferGeometry",
+  "octahedronBufferGeometry",
+  "planeBufferGeometry",
+  "polyhedronBufferGeometry",
+  "ringBufferGeometry",
+  "shapeBufferGeometry",
+  "sphereBufferGeometry",
+  "tetrahedronBufferGeometry",
+  "torusBufferGeometry",
+  "torusKnotBufferGeometry",
+  "tubeBufferGeometry",
+  "wireframeGeometry",
+  "tetrahedronGeometry",
+  "octahedronGeometry",
+  "icosahedronGeometry",
+  "dodecahedronGeometry",
+  "polyhedronGeometry",
+  "tubeGeometry",
+  "torusKnotGeometry",
+  "torusGeometry",
+  "sphereGeometry",
+  "ringGeometry",
+  "planeGeometry",
+  "latheGeometry",
+  "shapeGeometry",
+  "extrudeGeometry",
+  "edgesGeometry",
+  "coneGeometry",
+  "cylinderGeometry",
+  "circleGeometry",
+  "boxGeometry",
+  "capsuleGeometry",
+  "material",
+  "shadowMaterial",
+  "spriteMaterial",
+  "rawShaderMaterial",
+  "shaderMaterial",
+  "pointsMaterial",
+  "meshPhysicalMaterial",
+  "meshStandardMaterial",
+  "meshPhongMaterial",
+  "meshToonMaterial",
+  "meshNormalMaterial",
+  "meshLambertMaterial",
+  "meshDepthMaterial",
+  "meshDistanceMaterial",
+  "meshBasicMaterial",
+  "meshMatcapMaterial",
+  "lineDashedMaterial",
+  "lineBasicMaterial",
+  "primitive",
+  "light",
+  "spotLightShadow",
+  "spotLight",
+  "pointLight",
+  "rectAreaLight",
+  "hemisphereLight",
+  "directionalLightShadow",
+  "directionalLight",
+  "ambientLight",
+  "lightShadow",
+  "ambientLightProbe",
+  "hemisphereLightProbe",
+  "lightProbe",
+  "spotLightHelper",
+  "skeletonHelper",
+  "pointLightHelper",
+  "hemisphereLightHelper",
+  "gridHelper",
+  "polarGridHelper",
+  "directionalLightHelper",
+  "cameraHelper",
+  "boxHelper",
+  "box3Helper",
+  "planeHelper",
+  "arrowHelper",
+  "axesHelper",
+  "texture",
+  "videoTexture",
+  "dataTexture",
+  "dataTexture3D",
+  "compressedTexture",
+  "cubeTexture",
+  "canvasTexture",
+  "depthTexture",
+  "raycaster",
+  "vector2",
+  "vector3",
+  "vector4",
+  "euler",
+  "matrix3",
+  "matrix4",
+  "quaternion",
+  "bufferAttribute",
+  "float16BufferAttribute",
+  "float32BufferAttribute",
+  "float64BufferAttribute",
+  "int8BufferAttribute",
+  "int16BufferAttribute",
+  "int32BufferAttribute",
+  "uint8BufferAttribute",
+  "uint16BufferAttribute",
+  "uint32BufferAttribute",
+  "instancedBufferAttribute",
+  "color",
+  "fog",
+  "fogExp2",
+  "shape",
+  "colorShiftMaterial"
+], R = [
+  "AsciiRenderer",
+  "Billboard",
+  "Clone",
+  "ComputedAttribute",
+  "Decal",
+  "Edges",
+  "Effects",
+  "GradientTexture",
+  "Image",
+  "MarchingCubes",
+  "Outlines",
+  "PositionalAudio",
+  "Sampler",
+  "ScreenSizer",
+  "ScreenSpace",
+  "Splat",
+  "Svg",
+  "Text",
+  "Text3D",
+  "Trail",
+  "CubeCamera",
+  "OrthographicCamera",
+  "PerspectiveCamera",
+  "CameraControls",
+  "FaceControls",
+  "KeyboardControls",
+  "MotionPathControls",
+  "PresentationControls",
+  "ScrollControls",
+  "DragControls",
+  "GizmoHelper",
+  "Grid",
+  "Helper",
+  "PivotControls",
+  "TransformControls",
+  "CubeTexture",
+  "Fbx",
+  "Gltf",
+  "Ktx2",
+  "Loader",
+  "Progress",
+  "ScreenVideoTexture",
+  "Texture",
+  "TrailTexture",
+  "VideoTexture",
+  "WebcamVideoTexture",
+  "CycleRaycast",
+  "DetectGPU",
+  "Example",
+  "FaceLandmarker",
+  "Fbo",
+  "Html",
+  "Select",
+  "SpriteAnimator",
+  "StatsGl",
+  "Stats",
+  "Trail",
+  "Wireframe",
+  "CurveModifier",
+  "AdaptiveDpr",
+  "AdaptiveEvents",
+  "BakeShadows",
+  "Bvh",
+  "Detailed",
+  "Instances",
+  "Merged",
+  "meshBounds",
+  "PerformanceMonitor",
+  "Points",
+  "Preload",
+  "Segments",
+  "Fisheye",
+  "Hud",
+  "Mask",
+  "MeshPortalMaterial",
+  "RenderCubeTexture",
+  "RenderTexture",
+  "View",
+  "MeshDiscardMaterial",
+  "MeshDistortMaterial",
+  "MeshReflectorMaterial",
+  "MeshRefractionMaterial",
+  "MeshTransmissionMaterial",
+  "MeshWobbleMaterial",
+  "PointMaterial",
+  "shaderMaterial",
+  "SoftShadows",
+  "CatmullRomLine",
+  "CubicBezierLine",
+  "Facemesh",
+  "Line",
+  "Mesh",
+  "QuadraticBezierLine",
+  "RoundedBox",
+  "ScreenQuad",
+  "AccumulativeShadows",
+  "Backdrop",
+  "BBAnchor",
+  "Bounds",
+  "CameraShake",
+  "Caustics",
+  "Center",
+  "Cloud",
+  "ContactShadows",
+  "Environment",
+  "Float",
+  "Lightformer",
+  "MatcapTexture",
+  "NormalTexture",
+  "RandomizedLight",
+  "Resize",
+  "ShadowAlpha",
+  "Shadow",
+  "Sky",
+  "Sparkles",
+  "SpotLightShadow",
+  "SpotLight",
+  "Stage",
+  "Stars",
+  "OrbitControls"
+];
+function D(e) {
+  return !H.includes(e) && !R.includes(e);
+}
+const $ = /* @__PURE__ */ new Set([".jsx", ".tsx"]), b = F(), g = i.resolve(b, "./tailwind.config.ts"), j = i.resolve(b, "./src/tailwind.config.aippy.json"), y = i.resolve(b, "./.aippy.tailwind.config.js");
+function X() {
+  const e = process.cwd(), l = {
+    totalFiles: 0,
+    processedFiles: 0,
+    totalElements: 0
+  };
+  return {
+    name: "vite-plugin-aippy-tagger",
+    enforce: "pre",
+    async transform(n, r) {
+      if (!$.has(i.extname(r)) || r.includes("node_modules"))
+        return null;
+      l.totalFiles++;
+      const d = i.relative(e, r);
+      try {
+        const B = E(n, {
+          sourceType: "module",
+          plugins: ["jsx", "typescript"]
+        }), f = new P(n);
+        let x = 0, c = null;
+        const { walk: C } = await import("estree-walker");
+        return C(B, {
+          enter(m) {
+            if (m.type === "JSXElement" && (c = m), m.type === "JSXOpeningElement") {
+              const a = m;
+              let s;
+              if (a.name.type === "JSXIdentifier")
+                s = a.name.name;
+              else if (a.name.type === "JSXMemberExpression") {
+                const t = a.name;
+                s = `${t.object.name}.${t.property.name}`;
+              } else
+                return;
+              if (s === "Fragment" || s === "React.Fragment")
+                return;
+              const u = a.attributes.reduce((t, o) => (o.type === "JSXAttribute" && (o.value?.type === "StringLiteral" ? t[o.name.name] = o.value.value : o.value?.type === "JSXExpressionContainer" && o.value.expression.type === "StringLiteral" && (t[o.name.name] = o.value.expression.value)), t), {});
+              let h = "";
+              c && c.children && (h = c.children.map((t) => t.type === "JSXText" ? t.value.trim() : t.type === "JSXExpressionContainer" && t.expression.type === "StringLiteral" ? t.expression.value : "").filter(Boolean).join(" ").trim());
+              const p = {};
+              h && (p.text = h), u.placeholder && (p.placeholder = u.placeholder), u.className && (p.className = u.className);
+              const M = a.loc?.start?.line ?? 0, v = a.loc?.start?.column ?? 0, T = `${d}:${M}:${v}`, L = i.basename(r);
+              if (D(s)) {
+                const t = ` data-component-path="${d}" data-component-line="${M}" data-component-file="${L}" data-component-name="${s}" data-component-content="${encodeURIComponent(
+                  JSON.stringify(p)
+                )}"`;
+                f.appendLeft(
+                  a.name.end ?? 0,
+                  ` data-aippy-id="${T}" data-aippy-name="${s}" ${t}`
+                ), x++;
+              }
+            }
+          }
+        }), l.processedFiles++, l.totalElements += x, {
+          code: f.toString(),
+          map: f.generateMap({ hires: !0 })
+        };
+      } catch (S) {
+        return console.error(`Error processing file ${d}:`, S), l.processedFiles++, null;
+      }
+    },
+    async buildStart() {
+      try {
+        await w();
+      } catch (n) {
+        console.error("Error generating tailwind.config.aippy.json:", n);
+      }
+    },
+    configureServer(n) {
+      try {
+        n.watcher.add(g), n.watcher.on("change", async (r) => {
+          i.normalize(r) === i.normalize(g) && await w();
+        });
+      } catch (r) {
+        console.error("Error adding watcher:", r);
+      }
+    }
+  };
+}
+async function w() {
+  try {
+    await A.build({
+      entryPoints: [g],
+      outfile: y,
+      bundle: !0,
+      format: "esm",
+      banner: {
+        js: 'import { createRequire } from "module"; const require = createRequire(import.meta.url);'
+      }
+    });
+    try {
+      const e = await import(
+        y + "?update=" + Date.now()
+        // cache buster
+      );
+      if (!e || !e.default)
+        throw console.error("Invalid Tailwind config structure:", e), new Error("Invalid Tailwind config structure");
+      await G.writeFile(j, JSON.stringify(e.default, null, 2)), await G.unlink(y).catch(() => {
+      });
+    } catch (e) {
+      throw console.error("Error processing config:", e), e;
+    }
+  } catch (e) {
+    throw console.error("Error in generateConfig:", e), e;
+  }
+}
+export {
+  X as aippyTaggerPlugin,
+  X as default
+};

package/dist/aippy-tagger/util.d.ts

@@ -0,0 +1,3 @@
+export declare const threeFiberElems: string[];
+export declare const dreiElems: string[];
+export declare function shouldTagElement(elementName: string): boolean;

package/dist/aippy-tagger.d.ts

@@ -0,0 +1,6 @@
+export * from './aippy-tagger/index'
+export {}
+import _default from './aippy-tagger/index'
+export default _default
+export * from './aippy-tagger/index'
+export {}

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

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

package/dist/asset-constants/index.js

@@ -0,0 +1,255 @@
+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";
+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 {
+  constructor(s = {}) {
+    g(this, "options");
+    g(this, "assets", /* @__PURE__ */ new Map());
+    g(this, "existingAssets", /* @__PURE__ */ new Map());
+    this.options = {
+      extensions: [".png", ".jpg", ".jpeg", ".gif", ".svg", ".mp4", ".mp3", ".wav", ".ogg", ".webm"],
+      srcDir: "src",
+      outputFile: "src/config/assets.json",
+      devMode: !1,
+      ...s
+    };
+  }
+  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);
+  }
+  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;
+        e.push({
+          originalUri: i,
+          constantName: n,
+          filePath: s,
+          line: a,
+          column: 1
+        });
+      }), e;
+    } catch (t) {
+      return console.warn(`Warning: Failed to parse ${s}:`, t), [];
+    }
+  }
+  async scanAllTsFiles() {
+    const s = this.options.srcDir;
+    try {
+      const t = await this.getAllTsFiles(s);
+      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);
+        });
+      }
+    } 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");
+    } 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);
+    }
+  }
+  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");
+  }
+  getAssets() {
+    return Array.from(this.assets.values());
+  }
+  async replaceUrisInFile(s, t) {
+    try {
+      const e = await f.readFile(s, "utf-8"), o = F(e, {
+        sourceType: "module",
+        plugins: ["typescript", "jsx", "decorators-legacy"]
+      });
+      let i = !1;
+      if (A(o, {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        StringLiteral: (c) => {
+          const h = c.node.value, w = C(h);
+          if (t.has(w)) {
+            const x = t.get(w), y = u.memberExpression(
+              u.identifier("assetsData"),
+              u.identifier(x)
+            );
+            c.parent && u.isJSXAttribute(c.parent) ? c.replaceWith(u.jsxExpressionContainer(y)) : c.replaceWith(y), i = !0;
+          }
+        }
+      }), !i)
+        return;
+      const n = this.getRelativeImportPath(s, this.options.outputFile) + ".json";
+      let r = !1;
+      if (A(o, {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ImportDeclaration: (c) => {
+          c.node.source.value === n && (r = !0, c.stop());
+        }
+      }), !r) {
+        const c = u.importDeclaration(
+          [u.importDefaultSpecifier(u.identifier("assetsData"))],
+          u.stringLiteral(n)
+        );
+        o.program.body.unshift(c);
+      }
+      const a = U(o, {
+        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)}`);
+    } 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())
+      s.set(e.originalUri, e.constantName), t.add(e.filePath);
+    for (const e of t)
+      await this.replaceUrisInFile(e, s);
+  }
+  async cleanupUnusedConstants() {
+    try {
+      const s = await this.readExistingAssetsFile();
+      if (!s.trim())
+        return;
+      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);
+      } 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)
+        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);
+          } catch (r) {
+            console.warn(`Warning: Failed to read ${n}:`, r);
+          }
+      const i = [];
+      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) => {
+          console.log(`  - ${r}`);
+        });
+        const n = [];
+        for (const r of i) {
+          const a = t.get(r);
+          a && n.push(a);
+        }
+        for (const r of n)
+          this.assets.delete(r);
+      } else
+        console.log("✅ All constants are in use");
+    } catch (s) {
+      console.warn("Warning: Failed to cleanup unused constants:", s);
+    }
+  }
+}
+function z(l = {}) {
+  return {
+    name: "vite-plugin-asset-constants",
+    apply: "build",
+    async buildStart() {
+      if (l.devMode)
+        try {
+          const s = new E(l);
+          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(`
+🔄 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!
+`);
+        } catch (s) {
+          console.error("❌ Error in asset constants plugin:", s);
+        }
+    }
+  };
+}
+export {
+  z as assetConstantsPlugin,
+  z as default
+};

package/dist/asset-constants.d.ts

@@ -0,0 +1,6 @@
+export * from './asset-constants/index'
+export {}
+import _default from './asset-constants/index'
+export default _default
+export * from './asset-constants/index'
+export {}

package/dist/index/index.js

@@ -0,0 +1,15 @@
+import { assetConstantsPlugin as s, assetConstantsPlugin as o } from "../asset-constants/index.js";
+import { aippyPreloadPlugin as r } from "../aippy-preload/index.js";
+import { aippyTaggerPlugin as i } from "../aippy-tagger/index.js";
+import { extractAssetsFromContent as g, findProjectRoot as l, generateConstantName as f, isValidAsset as m, processAssetURL as P } from "../utils/index.js";
+export {
+  r as aippyPreloadPlugin,
+  i as aippyTaggerPlugin,
+  s as assetConstantsPlugin,
+  o as default,
+  g as extractAssetsFromContent,
+  l as findProjectRoot,
+  f as generateConstantName,
+  m as isValidAsset,
+  P as processAssetURL
+};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @aippy/vite-plugins
+ *
+ * Vite plugins collection for Aippy projects
+ * Provides asset management and component tagging capabilities
+ */
+export { assetConstantsPlugin } from './asset-constants/index';
+export { aippyPreloadPlugin } from './aippy-preload/index';
+export { aippyTaggerPlugin } from './aippy-tagger/index';
+export * from './utils/index';
+export { assetConstantsPlugin as default } from './asset-constants/index';

package/dist/utils/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Common utility functions for Aippy Vite plugins
+ */
+/**
+ * Process asset URL to ensure it's properly formatted
+ * @param url - The asset URL to process
+ * @returns Processed URL
+ */
+export declare function processAssetURL(url: string): string;
+/**
+ * Validate if an asset path is valid (not in node_modules, not too short, etc.)
+ * @param path - The asset path to validate
+ * @returns True if the path is valid
+ */
+export declare function isValidAsset(path: string): boolean;
+/**
+ * Generate a constant name for an asset based on its file extension
+ * @param uri - The asset URI
+ * @param existingNames - Set of existing constant names to avoid duplicates
+ * @returns Generated constant name
+ */
+export declare function generateConstantName(uri: string, existingNames?: Set<string>): string;
+/**
+ * Extract asset URLs from text content using regex patterns
+ * @param content - The text content to scan
+ * @param fileType - The type of file (html, js, css)
+ * @param extensions - Array of file extensions to match
+ * @returns Array of found asset URLs
+ */
+export declare function extractAssetsFromContent(content: string, fileType: 'html' | 'js' | 'css', extensions?: string[]): string[];
+/**
+ * Find the project root directory by looking for package.json
+ * @param startPath - Starting path to search from
+ * @returns Project root path
+ */
+export declare function findProjectRoot(startPath?: string): string;

package/dist/utils/index.js

@@ -0,0 +1,89 @@
+import { existsSync as l } from "fs";
+import g from "path";
+const h = [".png", ".jpg", ".jpeg", ".gif", ".svg", ".webp"], m = [".mp4", ".webm", ".mov", ".avi"], w = [".mp3", ".wav", ".ogg", ".m4a"];
+function p(e) {
+  return e.match(/^https?:\/\//) || e.match(/^data:/) || e.match(/^blob:/) || e.startsWith("/") ? e : `/${e}`;
+}
+function E(e) {
+  return !(e.includes("node_modules") || e.length < 4 || e.startsWith("./") && e.length < 10);
+}
+function R(e, t = /* @__PURE__ */ new Set()) {
+  let r = "ASSET";
+  h.some((n) => e.endsWith(n)) ? r = "IMAGE" : m.some((n) => e.endsWith(n)) ? r = "VIDEO" : w.some((n) => e.endsWith(n)) && (r = "AUDIO");
+  let o;
+  const s = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  do {
+    let n = "";
+    for (let c = 0; c < 4; c++)
+      n += s[Math.floor(Math.random() * s.length)];
+    o = `${r}_${n}`;
+  } while (t.has(o));
+  return o;
+}
+function d(e, t, r = [".js", ".css", ".png", ".jpg", ".jpeg", ".gif", ".svg", ".woff", ".woff2", ".ttf", ".eot"]) {
+  const o = /* @__PURE__ */ new Set(), s = r.map((n) => n.replace(/^\./, "")).join("|");
+  if (t === "html")
+    [
+      // src/href attributes for img, script, link, video, audio tags
+      new RegExp(`(?:src|href)=["']([^"']*\\.(?:${s}))["']`, "g"),
+      // url() in CSS
+      new RegExp(`url\\(["']?([^"']*\\.(?:${s}))["']?\\)`, "g")
+    ].forEach((a) => {
+      let i;
+      for (; (i = a.exec(e)) !== null; )
+        i[1] && o.add(p(i[1]));
+    }), (e.match(/<script[^>]*>[\s\S]*?<\/script>/g) || []).forEach((a) => {
+      const i = a.replace(/<script[^>]*>/, "").replace(/<\/script>/, "");
+      d(i, "js", r).forEach((f) => o.add(f));
+    });
+  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((c) => {
+      let a;
+      for (; (a = c.exec(e)) !== null; )
+        a[1] && E(a[1]) && o.add(p(a[1]));
+    });
+  else if (t === "css") {
+    const n = new RegExp(`url\\(["']?([^"']*\\.(?:${s}))["']?\\)`, "g");
+    let c;
+    for (; (c = n.exec(e)) !== null; )
+      c[1] && o.add(p(c[1]));
+  }
+  return Array.from(o);
+}
+function S(e = process.cwd()) {
+  try {
+    let t = e, r = 0;
+    for (; t !== g.parse(t).root && r < 20; ) {
+      if (l(g.join(t, "package.json")))
+        return t;
+      t = g.dirname(t), r++;
+    }
+    return process.cwd();
+  } catch (t) {
+    return console.error("Error finding project root:", t), process.cwd();
+  }
+}
+export {
+  d as extractAssetsFromContent,
+  S as findProjectRoot,
+  R as generateConstantName,
+  E as isValidAsset,
+  p as processAssetURL
+};

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export * from './utils/index'
+export {}

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "@aippy/vite-plugins",
+  "version": "0.2.0",
+  "description": "Vite plugins for Aippy projects - Asset management and component tagging",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index/index.js",
+  "module": "./dist/index/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./asset-constants": {
+      "import": "./dist/asset-constants/index.js",
+      "types": "./dist/asset-constants.d.ts"
+    },
+    "./aippy-preload": {
+      "import": "./dist/aippy-preload/index.js",
+      "types": "./dist/aippy-preload.d.ts"
+    },
+    "./aippy-tagger": {
+      "import": "./dist/aippy-tagger/index.js",
+      "types": "./dist/aippy-tagger.d.ts"
+    },
+    "./utils": {
+      "import": "./dist/utils/index.js",
+      "types": "./dist/utils.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "aippy",
+    "vite",
+    "vite-plugin",
+    "assets",
+    "preload",
+    "component-tagger",
+    "typescript"
+  ],
+  "author": "Aippy Team",
+  "license": "UNLICENSED",
+  "homepage": "https://aippy.ai",
+  "bugs": {
+    "url": "https://discord.com/invite/G94ZAx6gVq"
+  },
+  "dependencies": {
+    "@babel/generator": "^7.28.0",
+    "@babel/parser": "^7.28.0",
+    "@babel/traverse": "^7.28.0",
+    "@babel/types": "^7.28.2",
+    "esbuild": "^0.25.9",
+    "estree-walker": "^3.0.3",
+    "glob": "^11.0.3",
+    "magic-string": "^0.30.17"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.36.0",
+    "@types/babel__generator": "^7.6.8",
+    "@types/babel__traverse": "^7.20.6",
+    "@types/node": "^24.5.2",
+    "@typescript-eslint/eslint-plugin": "^8.44.1",
+    "@typescript-eslint/parser": "^8.44.1",
+    "eslint": "^9.36.0",
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.2",
+    "vite": "^7.1.7",
+    "vite-plugin-dts": "^4.5.4"
+  },
+  "peerDependencies": {
+    "vite": "^7.0.0 || ^6.0.0 || ^5.0.0"
+  },
+  "engines": {
+    "node": ">=20.0.0",
+    "pnpm": ">=10.0.0"
+  },
+  "scripts": {
+    "dev": "vite build --watch",
+    "build": "vite build && find dist -name '*.d.ts.map' -delete",
+    "type-check": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "format": "prettier --write \"src/**/*.{ts,json,md}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,json,md}\"",
+    "clean": "rm -rf dist",
+    "publish:patch": "pnpm version patch && pnpm publish --no-git-checks",
+    "publish:minor": "pnpm version minor && pnpm publish --no-git-checks",
+    "publish:major": "pnpm version major && pnpm publish --no-git-checks"
+  }
+}