@aippy/vite-plugins 0.4.0-dev.3 → 0.4.0-dev.5

package/dist/asset-constants-bI4rQJpw.js

@@ -0,0 +1,423 @@
+import { extractAssetsFromContent as e, generateConstantName as t, processAssetURL as n } from "./utils/index.js";
+import { a as r, c as i, i as a, l as o, n as s, o as c, r as l, s as u, t as d } from "./wrapper-keys-BPP5iTGM.js";
+import { promises as f } from "fs";
+import p from "path";
+import { parse as m } from "@babel/parser";
+import h from "@babel/traverse";
+import * as g from "@babel/types";
+import _ from "@babel/generator";
+//#region src/asset-constants/generator-utils.ts
+function v(e) {
+	if (!e || typeof e != "object" || Array.isArray(e)) return !1;
+	let t = e;
+	return typeof t.schemaVersion == "number" && !!t.assets && typeof t.assets == "object" && !Array.isArray(t.assets);
+}
+var y = [
+	"",
+	"-",
+	"--",
+	"tbd",
+	"todo",
+	"none",
+	"n/a",
+	"null",
+	"pending",
+	"not-generated",
+	"待生成",
+	"待制作"
+];
+function b(e) {
+	if (!e || Buffer.byteLength(e) > 4096 || /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f\uFEFF]/.test(e) || /[\s\\]/u.test(e) || e.startsWith("//") || /%(?![0-9a-f]{2})/i.test(e.split("?")[0]) || /%(?![0-9a-f]{2})/i.test(e.split("#")[1] ?? "")) return !1;
+	if (!/^[a-z][a-z0-9+.-]*:/i.test(e)) {
+		if (e.split(/[?#]/, 1)[0].split("/", 1)[0].includes(":")) return !1;
+		let t = e.split(/[?#]/, 1)[0].replace(/%([0-9a-f]{2})/gi, (e, t) => String.fromCharCode(Number.parseInt(t, 16)));
+		if (!t || t.endsWith("/") || y.includes(t.trim().toLowerCase())) return !1;
+		if (t.includes("/")) return !0;
+		let n = t.lastIndexOf(".");
+		return n > 0 && n < t.length - 1;
+	}
+	if (!/^https?:\/\//i.test(e)) return !1;
+	let t = e.slice(e.indexOf("://") + 3).split(/[/?#]/, 1)[0];
+	if (!t || t.includes("%")) return !1;
+	try {
+		let t = new URL(e);
+		return !!t.hostname && !t.username && !t.password;
+	} catch {
+		return !1;
+	}
+}
+function x(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let [n, r] of Object.entries(e)) typeof r != "string" || !b(r) || t.has(r) || t.set(r, n);
+	return t;
+}
+function S(e, t, n = {}) {
+	let r = { ...n }, i = new Set(Object.keys(r));
+	for (let [e, n] of t.entries()) i.has(n) || Object.values(r).includes(e) || (r[n] = e, i.add(n));
+	for (let t of e.values()) {
+		let e = Object.entries(r).find(([, e]) => e === t.originalUri);
+		if (e) {
+			t.constantName = e[0];
+			continue;
+		}
+		let n = t.constantName, a = n, o = 2;
+		for (; i.has(a);) a = `${n}_${o++}`;
+		i.add(a), t.constantName = a, r[a] = t.originalUri;
+	}
+	return 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);
+		if (v(n)) throw Error("assets: single-file asset plan is not supported");
+		if (!n || typeof n != "object" || Array.isArray(n)) throw Error("assets: URL dictionary object required");
+		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) {
+		throw e instanceof Error && e.message.startsWith("assets:") ? e : Error("assets: invalid JSON syntax");
+	}
+	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 h == "function" ? h : h.default, E = typeof _ == "function" ? _ : _.default, D = class extends Error {}, O = class {
+	constructor(e = {}) {
+		o(this, "options", void 0), o(this, "assets", /* @__PURE__ */ new Map()), o(this, "existingAssets", /* @__PURE__ */ new Map()), o(this, "flat", {}), o(this, "fileCache", new r()), o(this, "planKeys", void 0), o(this, "implementationPaths", /* @__PURE__ */ new Set()), o(this, "referencedFiles", /* @__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.planKeys ?? []
+		]);
+		return t(e, n);
+	}
+	async scanTsFile(t) {
+		try {
+			let n = await this.fileCache.read(t), r = [], i = e(n, "js", this.options.extensions), a = /* @__PURE__ */ new Set([...Object.keys(this.flat), ...this.planKeys ?? []]);
+			if (i.some((e) => a.has(e))) {
+				let r = s(n, t, this.options.srcDir, this.options.outputFile);
+				i = e(r, "js", this.options.extensions);
+			}
+			let o = n.split("\n"), c = x(this.flat);
+			i = i.filter((e) => n.includes(`"${e}"`) || n.includes(`'${e}'`)), 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
+				});
+			});
+			let l = new Set(r.map((e) => e.originalUri));
+			for (let [e, i] of c) l.has(e) || !n.includes(`"${e}"`) && !n.includes(`'${e}'`) || r.push({
+				originalUri: e,
+				constantName: i,
+				filePath: t,
+				line: 1,
+				column: 1
+			});
+			return r;
+		} catch (e) {
+			return console.warn(`Warning: Failed to scan ${t}:`, e), [];
+		}
+	}
+	async scanAllTsFiles() {
+		let e = this.options.srcDir;
+		this.referencedFiles.clear();
+		try {
+			let t = await u(e, [".ts", ".tsx"]);
+			for (let e of t) {
+				if (e.endsWith("assets.json") || e.endsWith("assets.ts")) continue;
+				let t = await this.scanTsFile(e), n = x(this.flat);
+				t.forEach((e) => {
+					let t = n.get(e.originalUri);
+					t ? e.constantName = t : this.existingAssets.has(e.originalUri) && (e.constantName = this.existingAssets.get(e.originalUri)), this.referencedFiles.add(e.filePath);
+					let r = e.originalUri;
+					this.assets.has(r) || this.assets.set(r, e);
+				});
+			}
+		} catch (e) {
+			console.error("Error scanning TypeScript files:", e);
+		}
+	}
+	async readExistingAssetsFile() {
+		try {
+			return await f.readFile(this.options.outputFile, "utf-8");
+		} catch (e) {
+			if (e.code === "ENOENT") return "";
+			throw new D("Unable to read assets.json: " + String(e));
+		}
+	}
+	sidecarPath() {
+		return p.resolve(this.options.srcDir, "..", "assets-plan.json");
+	}
+	async parseExistingAssets() {
+		let e = await this.readExistingAssetsFile();
+		if (e.trim()) {
+			let t;
+			try {
+				t = JSON.parse(e);
+			} catch {
+				throw new D("assets: invalid JSON syntax");
+			}
+			if (v(t)) throw new D("assets: single-file asset plan is not supported");
+			if (!t || typeof t != "object" || Array.isArray(t)) throw new D("assets: URL dictionary object required");
+			this.flat = { ...t };
+		}
+		try {
+			this.existingAssets = C(e);
+		} catch (e) {
+			throw new D(e instanceof Error ? e.message : "assets: invalid JSON syntax");
+		}
+		await this.readSidecar();
+	}
+	async readSidecar() {
+		let e = "";
+		try {
+			e = await f.readFile(this.sidecarPath(), "utf-8");
+		} catch (e) {
+			e.code !== "ENOENT" && console.warn("assets: unable to read assets-plan.json; continuing with the dictionary only");
+			return;
+		}
+		if (!e.trim()) return;
+		let t;
+		try {
+			t = JSON.parse(e);
+		} catch {
+			console.warn("assets: assets-plan.json is not valid JSON; continuing with the dictionary only");
+			return;
+		}
+		if (!v(t)) {
+			console.warn("assets: assets-plan.json is not a plan; continuing with the dictionary only");
+			return;
+		}
+		let n = t.assets;
+		this.planKeys = Object.keys(n);
+		let r = p.resolve(this.options.srcDir, "..");
+		for (let e of Object.values(n)) {
+			let t = e?.implementation?.path;
+			typeof t == "string" && t && this.implementationPaths.add(p.resolve(r, t));
+		}
+	}
+	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("@/") ? p.resolve(this.options.srcDir, n.slice(2)) : p.resolve(p.dirname(e), n);
+		return this.implementationPaths.has(r);
+	}
+	async generateAssetsFile() {
+		await this.parseExistingAssets(), await this.scanAllTsFiles();
+		let e = S(this.assets, this.existingAssets, this.flat);
+		try {
+			let t = p.dirname(this.options.outputFile);
+			await f.mkdir(t, { recursive: !0 }), await f.writeFile(this.options.outputFile, e, "utf-8"), await this.generateAssetsWrapper();
+		} catch (e) {
+			throw new D("Unable to write the asset dictionary or wrapper: " + String(e));
+		}
+		w(this.assets.size, this.existingAssets, this.assets, this.options.outputFile);
+	}
+	async generateAssetsWrapper() {
+		let e = this.options.outputFile.replace(/\.json$/, ".ts"), t = `// 🍎 Auto-generated wrapper for assets.json
+// This file handles iOS image replacement via asset-interceptor.js
+import assetsData from "./${p.basename(this.options.outputFile)}";
+
+// 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;
+`;
+		await f.writeFile(e, t, "utf-8"), console.log(`  ✓ Generated assets wrapper: ${p.relative(process.cwd(), e)}`);
+	}
+	getAssets() {
+		return Array.from(this.assets.values());
+	}
+	replaceLiteral(e, t, n) {
+		let r = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(n), i = g.memberExpression(g.identifier(t), r ? g.identifier(n) : g.stringLiteral(n), !r);
+		if ((g.isObjectProperty(e.parent) || g.isObjectMethod(e.parent) || g.isClassProperty(e.parent) || g.isClassMethod(e.parent)) && e.key === "key" && (e.parent.computed = !0), e.parent && g.isJSXAttribute(e.parent)) return e.replaceWith(g.jsxExpressionContainer(i)), !0;
+		try {
+			g.validate(e.parent, e.key, i);
+		} catch {
+			return !1;
+		}
+		return e.replaceWith(i), !0;
+	}
+	async replaceUrisInFile(e, t) {
+		try {
+			let r = await this.fileCache.read(e), i = m(r, {
+				sourceType: "module",
+				plugins: [
+					"typescript",
+					"jsx",
+					"decorators-legacy"
+				]
+			}), o = !1, s = this.options.outputFile.replace(/\.json$/, ".ts"), u = c(s, this.options.srcDir), h = l(e, this.options.srcDir, this.options.outputFile), _ = a(i, h), v = "assetsData", y = !1, b, x = /* @__PURE__ */ new Set();
+			T(i, {
+				Identifier: (e) => {
+					x.add(e.node.name);
+				},
+				ImportDeclaration: (e) => {
+					if (!(!h.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);
+						d(t) && (v = t.local.name, y = !0, b = n);
+					}
+				}
+			});
+			let S = !1;
+			if (y && T(i, { StringLiteral: (r) => {
+				!g.isImportDeclaration(r.parent) && !_(r) && !this.isImplementationReference(e, r.node.value) && t.has(n(r.node.value)) && r.scope.getBinding(v) !== b && (S = !0);
+			} }), !y && x.has(v) || S) {
+				let e = "aippyAssetsData";
+				for (let t = 2; x.has(e); t++) e = `aippyAssetsData${t}`;
+				S && b.scope.rename(v, e), v = e;
+			}
+			if (T(i, { StringLiteral: (r) => {
+				let i = r.node.value;
+				if (this.isImplementationReference(e, i) || _(r) || g.isImportDeclaration(r.parent) || g.isExportNamedDeclaration(r.parent) || g.isExportAllDeclaration(r.parent) || r.findParent((e) => g.isTSType(e.node) || g.isTSInterfaceBody(e.node))) return;
+				let a = n(i);
+				if (t.has(a)) {
+					let e = t.get(a);
+					this.replaceLiteral(r, v, e) && (r.skip(), o = !0);
+				}
+			} }), !o) return;
+			if (!y) {
+				let e = g.importDeclaration([g.importDefaultSpecifier(g.identifier(v))], g.stringLiteral(u));
+				i.program.body.unshift(e);
+			}
+			let C = E(i, {
+				retainLines: !1,
+				comments: !0,
+				compact: !1
+			}, r);
+			await f.writeFile(e, C.code, "utf-8"), this.fileCache.invalidate(e), console.log(`  ✓ Replaced URIs in ${p.relative(process.cwd(), e)}`);
+		} catch (t) {
+			console.warn(`Warning: Failed to replace URIs in ${e}:`, t);
+		}
+	}
+	async replaceAllUris() {
+		let e = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Set();
+		for (let t of this.assets.values()) e.set(t.originalUri, t.constantName);
+		for (let e of this.referencedFiles) t.add(e);
+		for (let n of t) await this.replaceUrisInFile(n, e);
+	}
+	needsRewrite() {
+		return this.assets.size > 0;
+	}
+	async cleanupUnusedConstants() {
+		if (!this.planKeys) 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 u(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 = c(e, this.options.srcDir), n = await u(this.options.srcDir, [".ts", ".tsx"]), r = 0;
+		for (let a of n) if (!(a.endsWith("assets.ts") || a.endsWith("assets.json"))) try {
+			let n = await this.fileCache.read(a), o = i(a, this.options.outputFile) + ".json", s = i(a, e), l = c(this.options.outputFile, this.options.srcDir) + ".json";
+			if (!n.includes(o) && !n.includes(s) && !n.includes(l)) continue;
+			let u = m(n, {
+				sourceType: "module",
+				plugins: [
+					"typescript",
+					"jsx",
+					"decorators-legacy"
+				]
+			}), d = !1;
+			if (T(u, { ImportDeclaration: (e) => {
+				let n = e.node.source.value;
+				(n === o || n === s || n === l) && (e.node.source.value = t, d = !0);
+			} }), d) {
+				let e = E(u, {
+					retainLines: !1,
+					comments: !0,
+					compact: !1
+				}, n);
+				await f.writeFile(a, e.code, "utf-8"), this.fileCache.invalidate(a), console.log(`  ✓ Upgraded import in ${p.relative(process.cwd(), a)} → ${t}`), r++;
+			}
+		} catch (e) {
+			console.warn(`Warning: Failed to upgrade imports in ${a}:`, 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();
+				t.needsRewrite() && (console.log(`📦 Found ${e.length} asset references:`), e.forEach((e) => {
+					console.log(`  ${e.constantName} = '${e.originalUri}' (${p.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 && this.error(e.message);
+			}
+		}
+	};
+}
+//#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 { assetConstantsPlugin as a } from "../asset-constants/index.js";
-import { t as o } from "../aippy-preload-DtngFmJ5.js";
+import { t as a } from "../asset-constants-bI4rQJpw.js";
+import { t as o } from "../aippy-preload-DZsYdwMm.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 };

package/dist/wrapper-keys-BPP5iTGM.js

@@ -0,0 +1,126 @@
+import { promises as e } from "fs";
+import t from "path";
+import { parse as n } from "@babel/parser";
+import r from "@babel/traverse";
+import * as i from "@babel/types";
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/typeof.js
+function a(e) {
+	"@babel/helpers - typeof";
+	return a = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
+		return typeof e;
+	} : function(e) {
+		return e && typeof Symbol == "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+	}, a(e);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/toPrimitive.js
+function o(e, t) {
+	if (a(e) != "object" || !e) return e;
+	var n = e[Symbol.toPrimitive];
+	if (n !== void 0) {
+		var r = n.call(e, t || "default");
+		if (a(r) != "object") return r;
+		throw TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return (t === "string" ? String : Number)(e);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/toPropertyKey.js
+function s(e) {
+	var t = o(e, "string");
+	return a(t) == "symbol" ? t : t + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.144.0/helpers/esm/defineProperty.js
+function c(e, t, n) {
+	return (t = s(t)) in e ? Object.defineProperty(e, t, {
+		value: n,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[t] = n, e;
+}
+//#endregion
+//#region src/utils/file-scanner.ts
+async function l(n, r) {
+	let i = [];
+	try {
+		let a = await e.readdir(n, { withFileTypes: !0 });
+		for (let e of a) {
+			let a = t.join(n, e.name);
+			if (e.isDirectory()) {
+				let e = await l(a, r);
+				i.push(...e);
+			} else if (e.isFile()) {
+				let n = t.extname(e.name);
+				r.includes(n) && i.push(a);
+			}
+		}
+	} catch (e) {
+		console.warn(`Warning: Failed to read directory ${n}:`, e);
+	}
+	return i;
+}
+function u(e, n) {
+	let r = t.relative(t.dirname(e), n).replace(/\.(ts|tsx|js|jsx|json)$/, "");
+	return r.startsWith(".") ? r : `./${r}`;
+}
+function d(e, n) {
+	return `@/${t.relative(n, e).replace(/\.(ts|tsx|js|jsx|json)$/, "")}`;
+}
+var f = class {
+	constructor() {
+		c(this, "cache", /* @__PURE__ */ new Map());
+	}
+	async read(t) {
+		if (this.cache.has(t)) return this.cache.get(t);
+		let n = await e.readFile(t, "utf-8");
+		return this.cache.set(t, n), n;
+	}
+	invalidate(e) {
+		this.cache.delete(e);
+	}
+	clear() {
+		this.cache.clear();
+	}
+}, p = typeof r == "function" ? r : r.default;
+function m(e) {
+	return i.isImportDefaultSpecifier(e) || i.isImportSpecifier(e) && (i.isIdentifier(e.imported, { name: "default" }) || i.isStringLiteral(e.imported, { value: "default" }));
+}
+function h(e, t) {
+	let n = /* @__PURE__ */ new Set();
+	return p(e, { ImportDeclaration: (e) => {
+		if (!(!t.has(e.node.source.value) || e.node.importKind === "type")) for (let t of e.node.specifiers) t.importKind !== "type" && m(t) && n.add(e.scope.getBinding(t.local.name));
+	} }), (e) => {
+		let t = e.parent;
+		return (i.isMemberExpression(t) || i.isOptionalMemberExpression(t)) && t.computed && e.key === "property" && i.isIdentifier(t.object) && n.has(e.scope.getBinding(t.object.name));
+	};
+}
+function g(e, t, n) {
+	let r = n.replace(/\.json$/, ".ts"), i = d(r, t), a = u(e, r);
+	return /* @__PURE__ */ new Set([
+		i,
+		i + ".ts",
+		a,
+		a + ".ts",
+		u(e, n) + ".json",
+		"@/config/assets.json"
+	]);
+}
+function _(e, t, r, i) {
+	let a = n(e, {
+		sourceType: "module",
+		plugins: [
+			"typescript",
+			"jsx",
+			"decorators-legacy"
+		]
+	}), o = h(a, g(t, r, i)), s = [];
+	p(a, { StringLiteral: (e) => {
+		o(e) && s.push([e.node.start, e.node.end]);
+	} });
+	for (let [t, n] of s.sort((e, t) => t[0] - e[0])) e = e.slice(0, t) + " ".repeat(n - t) + e.slice(n);
+	return e;
+}
+//#endregion
+export { f as a, u as c, h as i, c as l, _ as n, d as o, g as r, l as s, m as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aippy/vite-plugins",
-  "version": "0.4.0-dev.3",
+  "version": "0.4.0-dev.5",
   "description": "Vite plugins for Aippy projects - Asset management and component tagging",
   "private": false,
   "type": "module",
@@ -27,13 +27,11 @@
     "./utils": {
       "import": "./dist/utils/index.js",
       "types": "./dist/utils.d.ts"
-    },
-    "./assets.schema.json": "./src/asset-constants/assets.schema.json"
+    }
   },
   "files": [
     "dist",
-    "README.md",
-    "src/asset-constants/assets.schema.json"
+    "README.md"
   ],
   "publishConfig": {
     "access": "public"

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

@@ -1,53 +0,0 @@
-export interface AssetError {
-    stage: string;
-    code: string;
-    message: string;
-    retryable: boolean;
-}
-export interface AssetParams {
-    width?: number;
-    height?: number;
-    durationSeconds?: number;
-    loop?: boolean;
-}
-export interface AssetImplementation {
-    method: 'svg' | 'canvas' | 'css' | 'synth' | 'animation' | 'three';
-    description: string;
-    status: 'planned' | 'ready';
-    path?: string;
-    symbol?: string;
-}
-export interface AssetEntry {
-    type: string;
-    source: 'generated' | 'user' | 'existing' | 'code';
-    replaceable: boolean;
-    description: string;
-    params?: AssetParams;
-    generation?: {
-        action: 'generate' | 'reuse';
-        prompt: string;
-    };
-    status: 'planned' | 'ready' | 'failed' | 'skipped' | 'degraded';
-    url?: string;
-    output?: {
-        format?: string;
-        width?: number;
-        height?: number;
-        durationSeconds?: number;
-    };
-    error?: AssetError;
-    implementation?: AssetImplementation;
-}
-export interface AssetManifest {
-    schemaVersion: 1;
-    artStyle: string;
-    assets: Record<string, AssetEntry>;
-    planningError?: AssetError;
-    legacyInventory?: string;
-    legacyPlaceholderKeys?: string[];
-}
-export type AssetDocument = AssetManifest | Record<string, string>;
-export declare function isManifest(doc: AssetDocument): doc is AssetManifest;
-export declare function parseAssetDocument(content: string): AssetDocument;
-export declare function assetUrlMap(document: AssetDocument): Record<string, string>;
-export declare function inferExistingType(uri: string): string;