@aippy/vite-plugins 0.2.9-dev.0 → 0.4.0-dev.1

package/dist/asset-constants-C59CLHCE.js

@@ -0,0 +1,359 @@
+import { extractAssetsFromContent as e, generateConstantName as t, processAssetURL as n } from "./utils/index.js";
+import { a as r, c as i, d as a, f as o, i as s, l as c, n as l, o as u, p as d, r as f, s as p, t as m, u as h } from "./manifest-CI1ALLzl.js";
+import { promises as g } from "fs";
+import _ from "path";
+import { parse as v } from "@babel/parser";
+import y from "@babel/traverse";
+import * as b from "@babel/types";
+import x from "@babel/generator";
+//#region src/asset-constants/generator-utils.ts
+function S(e, t, n) {
+	if (n && f(n)) {
+		let t = structuredClone(n), r = new Set(Object.keys(t.assets));
+		for (let n of e.values()) {
+			let e = Object.keys(t.assets).filter((e) => t.assets[e].url === n.originalUri);
+			if (e.length) {
+				n.constantName = e[0];
+				continue;
+			}
+			let i = n.constantName, a = i, o = 2;
+			for (; r.has(a);) a = `${i}_${o++}`;
+			r.add(a), n.constantName = a, t.assets[a] = {
+				type: l(n.originalUri),
+				source: "existing",
+				replaceable: !0,
+				description: `Existing asset ${a}`,
+				status: "ready",
+				url: n.originalUri
+			};
+		}
+		return JSON.stringify(t, null, 2) + "\n";
+	}
+	let r = {};
+	for (let [e, n] of t.entries()) r[n] = e;
+	return Array.from(e.values()).forEach((e) => {
+		r[e.constantName] = e.originalUri;
+	}), JSON.stringify(r, null, 2) + "\n";
+}
+function C(e) {
+	let t = /* @__PURE__ */ new Map();
+	try {
+		if (!e.trim()) return t;
+		let n = JSON.parse(e);
+		for (let [e, r] of Object.entries(n)) typeof r == "string" && t.set(r, e);
+		t.size > 0 && console.log(`📋 Found ${t.size} existing constants in assets.json`);
+	} catch (e) {
+		console.warn("Warning: Failed to parse existing assets.json:", e);
+	}
+	return t;
+}
+function w(e, t, n, r) {
+	let i = Array.from(n.values()).filter((e) => t.has(e.originalUri)).length, a = e - i;
+	console.log(a > 0 ? `✅ Generated ${e} asset constants (${a} new, ${i} reused) in ${r}` : e > 0 ? `✅ Generated ${e} asset constants (all reused from existing) in ${r}` : "✅ No asset constants found");
+}
+//#endregion
+//#region src/asset-constants/index.ts
+var T = typeof y == "function" ? y : y.default, E = typeof x == "function" ? x : x.default, D = class extends Error {}, O = class {
+	isStructuredInventory() {
+		return this.document !== void 0 && f(this.document);
+	}
+	constructor(e = {}) {
+		d(this, "options", void 0), d(this, "assets", /* @__PURE__ */ new Map()), d(this, "existingAssets", /* @__PURE__ */ new Map()), d(this, "fileCache", new c()), d(this, "document", void 0), d(this, "implementationPaths", /* @__PURE__ */ new Set()), this.options = {
+			extensions: [
+				".png",
+				".jpg",
+				".jpeg",
+				".gif",
+				".svg",
+				".mp4",
+				".mp3",
+				".wav",
+				".ogg",
+				".webm"
+			],
+			srcDir: "src",
+			outputFile: "src/config/assets.json",
+			devMode: !1,
+			...e
+		};
+	}
+	clearCache() {
+		this.fileCache.clear();
+	}
+	generateConstantName(e) {
+		let n = /* @__PURE__ */ new Set([
+			...Array.from(this.assets.values()).map((e) => e.constantName),
+			...Array.from(this.existingAssets.values()),
+			...this.document && f(this.document) ? Object.keys(this.document.assets) : []
+		]);
+		return t(e, n);
+	}
+	async scanTsFile(t) {
+		try {
+			let n = await this.fileCache.read(t), r = [], i = e(n, "js", this.options.extensions), a = this.document;
+			if (a && f(a) && i.some((e) => Object.hasOwn(a.assets, e))) {
+				let r = u(n, t, this.options.srcDir, this.options.outputFile);
+				i = e(r, "js", this.options.extensions);
+			}
+			let o = n.split("\n");
+			return i.forEach((e) => {
+				if (this.isImplementationReference(t, e)) return;
+				let n = this.generateConstantName(e), i = o.findIndex((t) => t.includes(e)) + 1;
+				r.push({
+					originalUri: e,
+					constantName: n,
+					filePath: t,
+					line: i,
+					column: 1
+				});
+			}), r;
+		} catch (e) {
+			return console.warn(`Warning: Failed to scan ${t}:`, e), [];
+		}
+	}
+	async scanAllTsFiles() {
+		let e = this.options.srcDir;
+		try {
+			let t = await a(e, [".ts", ".tsx"]);
+			for (let e of t) e.endsWith("assets.json") || e.endsWith("assets.ts") || (await this.scanTsFile(e)).forEach((e) => {
+				this.existingAssets.has(e.originalUri) && (e.constantName = this.existingAssets.get(e.originalUri));
+				let t = e.originalUri;
+				this.assets.has(t) || this.assets.set(t, e);
+			});
+		} catch (e) {
+			console.error("Error scanning TypeScript files:", e);
+		}
+	}
+	async readExistingAssetsFile() {
+		try {
+			return await g.readFile(this.options.outputFile, "utf-8");
+		} catch (e) {
+			if (e.code === "ENOENT") return "";
+			throw new D("Unable to read assets.json: " + String(e));
+		}
+	}
+	async parseExistingAssets() {
+		let e = await this.readExistingAssetsFile();
+		if (e.trim()) {
+			let t;
+			try {
+				t = JSON.parse(e);
+			} catch {
+				if (/"schemaVersion(?:["\s:]|$)/i.test(e.replace(/\\u([0-9a-f]{4})/gi, (e, t) => String.fromCharCode(parseInt(t, 16))))) throw new D("assets: invalid JSON syntax");
+			}
+			if (t && Object.prototype.hasOwnProperty.call(t, "schemaVersion")) {
+				try {
+					this.document = s(e);
+				} catch (e) {
+					throw new D(e instanceof Error ? e.message : "Invalid asset manifest");
+				}
+				this.existingAssets = /* @__PURE__ */ new Map();
+				for (let [e, t] of Object.entries(m(this.document))) this.existingAssets.has(t) || this.existingAssets.set(t, e);
+				if (f(this.document)) {
+					let e = _.dirname(_.resolve(this.options.srcDir));
+					this.implementationPaths = new Set(Object.values(this.document.assets).filter((e) => (e.source === "code" || e.source === "generated") && e.implementation?.path).map((t) => _.resolve(e, t.implementation.path)));
+				}
+				return;
+			}
+		}
+		this.existingAssets = C(e);
+	}
+	isImplementationReference(e, t) {
+		if (!this.implementationPaths.size || /^[a-z][a-z0-9+.-]*:/i.test(t) || t.startsWith("//")) return !1;
+		let n = t.split(/[?#]/)[0], r = n.startsWith("@/") ? _.resolve(this.options.srcDir, n.slice(2)) : _.resolve(_.dirname(e), n);
+		return this.implementationPaths.has(r);
+	}
+	async generateAssetsFile() {
+		await this.parseExistingAssets(), await this.scanAllTsFiles();
+		let e = S(this.assets, this.existingAssets, this.document), t = _.dirname(this.options.outputFile);
+		if (await g.mkdir(t, { recursive: !0 }), this.document && f(this.document)) try {
+			this.document = s(e);
+		} catch (e) {
+			throw new D(e instanceof Error ? e.message : "Invalid supplementary asset");
+		}
+		await g.writeFile(this.options.outputFile, e, "utf-8"), await this.generateAssetsWrapper(), w(this.assets.size, this.existingAssets, this.assets, this.options.outputFile);
+	}
+	async generateAssetsWrapper() {
+		let e = this.options.outputFile.replace(/\.json$/, ".ts"), t = _.basename(this.options.outputFile), n = `// 🍎 Auto-generated wrapper for assets.json
+// This file handles iOS image replacement via asset-interceptor.js
+import assetsData from "./${t}";
+
+// Batch process all asset URLs for potential replacements
+// sessionStorage may contain __aippy_asset_overrides__ with multiple image mappings
+(window as any).getReplacedAssets?.(assetsData);
+
+export default assetsData;
+`;
+		if (this.document && f(this.document)) {
+			let e = Object.keys(m(this.document));
+			n = `// Auto-generated asset URL map. Planning metadata stays in assets.json.
+import manifest from "./${t}";
+const keys = ${JSON.stringify(e)} as const;
+const assetsData = ${e.length ? "Object.fromEntries(keys.map(name => [name, manifest.assets[name].url]))" : "{}"} as { [K in typeof keys[number]]: string };
+(window as any).getReplacedAssets?.(assetsData);
+export default assetsData;
+`;
+		}
+		await g.writeFile(e, n, "utf-8"), console.log(`  ✓ Generated assets wrapper: ${_.relative(process.cwd(), e)}`);
+	}
+	getAssets() {
+		return Array.from(this.assets.values());
+	}
+	async replaceUrisInFile(e, t) {
+		try {
+			let a = await this.fileCache.read(e), o = v(a, {
+				sourceType: "module",
+				plugins: [
+					"typescript",
+					"jsx",
+					"decorators-legacy"
+				]
+			}), s = !1, c = this.options.outputFile.replace(/\.json$/, ".ts"), l = h(c, this.options.srcDir), u = p(e, this.options.srcDir, this.options.outputFile), d = i(o, u), f = "assetsData", m = !1, y, x = /* @__PURE__ */ new Set();
+			T(o, {
+				Identifier: (e) => {
+					x.add(e.node.name);
+				},
+				ImportDeclaration: (e) => {
+					if (!(!u.has(e.node.source.value) || e.node.importKind === "type")) for (let t of e.node.specifiers) {
+						if (t.importKind === "type") continue;
+						let n = e.scope.getBinding(t.local.name);
+						r(t) && (f = t.local.name, m = !0, y = n);
+					}
+				}
+			});
+			let S = !1;
+			if (m && T(o, { StringLiteral: (r) => {
+				!b.isImportDeclaration(r.parent) && !d(r) && !this.isImplementationReference(e, r.node.value) && t.has(n(r.node.value)) && r.scope.getBinding(f) !== y && (S = !0);
+			} }), !m && x.has(f) || S) {
+				let e = "aippyAssetsData";
+				for (let t = 2; x.has(e); t++) e = `aippyAssetsData${t}`;
+				S && y.scope.rename(f, e), f = e;
+			}
+			if (T(o, { StringLiteral: (r) => {
+				let i = r.node.value;
+				if (this.isImplementationReference(e, i) || d(r) || b.isImportDeclaration(r.parent) || b.isExportNamedDeclaration(r.parent) || b.isExportAllDeclaration(r.parent) || r.findParent((e) => b.isTSType(e.node) || b.isTSInterfaceBody(e.node))) return;
+				let a = n(i);
+				if (t.has(a)) {
+					let e = t.get(a), n = b.memberExpression(b.identifier(f), /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(e) ? b.identifier(e) : b.stringLiteral(e), !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(e));
+					if ((b.isObjectProperty(r.parent) || b.isObjectMethod(r.parent) || b.isClassProperty(r.parent) || b.isClassMethod(r.parent)) && r.key === "key" && (r.parent.computed = !0), r.parent && b.isJSXAttribute(r.parent)) r.replaceWith(b.jsxExpressionContainer(n));
+					else {
+						try {
+							b.validate(r.parent, r.key, n);
+						} catch {
+							return;
+						}
+						r.replaceWith(n);
+					}
+					r.skip(), s = !0;
+				}
+			} }), !s) return;
+			if (!m) {
+				let e = b.importDeclaration([b.importDefaultSpecifier(b.identifier(f))], b.stringLiteral(l));
+				o.program.body.unshift(e);
+			}
+			let C = E(o, {
+				retainLines: !1,
+				comments: !0,
+				compact: !1
+			}, a);
+			await g.writeFile(e, C.code, "utf-8"), this.fileCache.invalidate(e), console.log(`  ✓ Replaced URIs in ${_.relative(process.cwd(), e)}`);
+		} catch (t) {
+			if (this.isStructuredInventory()) throw t;
+			console.warn(`Warning: Failed to replace URIs in ${e}:`, t);
+		}
+	}
+	async replaceAllUris() {
+		let e = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Set();
+		for (let n of this.assets.values()) e.set(n.originalUri, n.constantName), t.add(n.filePath);
+		for (let n of t) await this.replaceUrisInFile(n, e);
+	}
+	async cleanupUnusedConstants() {
+		if (!(this.document && f(this.document))) try {
+			let e = await this.readExistingAssetsFile();
+			if (!e.trim()) return;
+			let t = /* @__PURE__ */ new Map();
+			try {
+				let n = JSON.parse(e);
+				for (let [e, r] of Object.entries(n)) typeof r == "string" && t.set(e, r);
+			} catch (e) {
+				console.warn("Warning: Failed to parse assets.json:", e);
+				return;
+			}
+			if (t.size === 0) return;
+			let n = /* @__PURE__ */ new Set(), r = await a(this.options.srcDir, [".ts", ".tsx"]);
+			for (let e of r) if (!(e.endsWith("assets.json") || e.endsWith("assets.ts"))) try {
+				let r = await this.fileCache.read(e);
+				for (let e of t.keys()) r.includes(e) && n.add(e);
+			} catch (t) {
+				console.warn(`Warning: Failed to read ${e}:`, t);
+			}
+			let i = [];
+			for (let e of t.keys()) n.has(e) || i.push(e);
+			if (i.length > 0) {
+				console.log(`🧹 Removing ${i.length} unused constant(s):`), i.forEach((e) => {
+					console.log(`  - ${e}`);
+				});
+				let e = [];
+				for (let n of i) {
+					let r = t.get(n);
+					r && e.push(r);
+				}
+				for (let t of e) this.assets.delete(t);
+			} else console.log("✅ All constants are in use");
+		} catch (e) {
+			console.warn("Warning: Failed to cleanup unused constants:", e);
+		}
+	}
+	async upgradeJsonImportsToTs() {
+		let e = this.options.outputFile.replace(/\.json$/, ".ts"), t = h(e, this.options.srcDir), n = await a(this.options.srcDir, [".ts", ".tsx"]), r = 0;
+		for (let i of n) if (!(i.endsWith("assets.ts") || i.endsWith("assets.json"))) try {
+			let n = await this.fileCache.read(i), a = o(i, this.options.outputFile) + ".json", s = o(i, e), c = h(this.options.outputFile, this.options.srcDir) + ".json";
+			if (!n.includes(a) && !n.includes(s) && !n.includes(c)) continue;
+			let l = v(n, {
+				sourceType: "module",
+				plugins: [
+					"typescript",
+					"jsx",
+					"decorators-legacy"
+				]
+			}), u = !1;
+			if (T(l, { ImportDeclaration: (e) => {
+				let n = e.node.source.value;
+				(n === a || n === s || n === c) && (e.node.source.value = t, u = !0);
+			} }), u) {
+				let e = E(l, {
+					retainLines: !1,
+					comments: !0,
+					compact: !1
+				}, n);
+				await g.writeFile(i, e.code, "utf-8"), this.fileCache.invalidate(i), console.log(`  ✓ Upgraded import in ${_.relative(process.cwd(), i)} → ${t}`), r++;
+			}
+		} catch (e) {
+			if (this.isStructuredInventory()) throw e;
+			console.warn(`Warning: Failed to upgrade imports in ${i}:`, e);
+		}
+		r > 0 && console.log(`✅ Upgraded ${r} file(s) to use ${t}`);
+	}
+};
+function k(e = {}) {
+	return {
+		name: "vite-plugin-asset-constants",
+		apply: "build",
+		enforce: "pre",
+		async buildStart() {
+			if (!e.devMode) return;
+			let t = new O(e);
+			try {
+				await t.generateAssetsFile();
+				let e = t.getAssets();
+				e.length > 0 && (console.log(`📦 Found ${e.length} asset references:`), e.forEach((e) => {
+					console.log(`  ${e.constantName} = '${e.originalUri}' (${_.relative(process.cwd(), e.filePath)}:${e.line})`);
+				}), console.log("\n🔄 Replacing URIs with constants..."), await t.replaceAllUris(), console.log("✅ URI replacement completed!")), console.log("\n🧹 Checking for unused constants..."), await t.cleanupUnusedConstants(), await t.generateAssetsFile(), console.log("\n🔄 Upgrading assets.json imports to assets.ts..."), await t.upgradeJsonImportsToTs(), console.log("✅ Asset constants finalized!\n"), t.clearCache();
+			} catch (e) {
+				console.error("❌ Error in asset constants plugin:", e), (e instanceof D || t.isStructuredInventory()) && this.error(e instanceof Error ? e.message : String(e));
+			}
+		}
+	};
+}
+//#endregion
+export { k as t };

package/dist/index/index.js

@@ -1,5 +1,5 @@
 import { extractAssetsFromContent as e, findProjectRoot as t, generateConstantName as n, isValidAsset as r, processAssetURL as i } from "../utils/index.js";
-import { t as a } from "../asset-constants-BvKclVVI.js";
-import { t as o } from "../aippy-preload-8BoWu90-.js";
+import { t as a } from "../asset-constants-C59CLHCE.js";
+import { t as o } from "../aippy-preload-QZY6fyKx.js";
 import { t as s } from "../aippy-tagger-By5socAS.js";
 export { o as aippyPreloadPlugin, s as aippyTaggerPlugin, a as assetConstantsPlugin, a as default, e as extractAssetsFromContent, t as findProjectRoot, n as generateConstantName, r as isValidAsset, i as processAssetURL };