@aippy/vite-plugins 0.3.0 → 0.4.0-dev.1

package/dist/manifest-CI1ALLzl.js

@@ -0,0 +1,365 @@
+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) {
+	return i.isTSAsExpression(e) || i.isTSTypeAssertion(e) || i.isTSNonNullExpression(e) || i.isTSSatisfiesExpression(e) || i.isParenthesizedExpression(e);
+}
+function g(e) {
+	for (; h(e);) e = e.expression;
+	return e;
+}
+function _(e, t) {
+	let n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set();
+	p(e, { ImportDeclaration: (e) => {
+		if (!(!t.has(e.node.source.value) || e.node.importKind === "type")) for (let t of e.node.specifiers) {
+			if (t.importKind === "type") continue;
+			let a = e.scope.getBinding(t.local.name);
+			i.isImportNamespaceSpecifier(t) && r.add(a), m(t) && n.add(a);
+		}
+	} });
+	let a = (e, t, o = /* @__PURE__ */ new Set()) => {
+		if (e = g(e), i.isIdentifier(e)) {
+			let s = t.getBinding(e.name);
+			if (n.has(s)) return "map";
+			if (r.has(s)) return "namespace";
+			if (s?.constant && s.kind === "const" && !o.has(s) && s.path.isVariableDeclarator() && s.path.node.init) {
+				o.add(s);
+				let t = s.path.node, n = a(t.init, s.path.scope, o);
+				if (i.isIdentifier(t.id, { name: e.name })) return n;
+				if (n === "namespace" && i.isObjectPattern(t.id) && t.id.properties.find((t) => i.isObjectProperty(t) && i.isIdentifier(t.value, { name: e.name }) && (t.computed ? i.isStringLiteral(g(t.key), { value: "default" }) : i.isIdentifier(t.key, { name: "default" }) || i.isStringLiteral(t.key, { value: "default" })))) return "map";
+			}
+		}
+		if ((i.isMemberExpression(e) || i.isOptionalMemberExpression(e)) && (e.computed ? i.isStringLiteral(g(e.property), { value: "default" }) : i.isIdentifier(e.property, { name: "default" })) && a(e.object, t, o) === "namespace") return "map";
+	};
+	return (e) => {
+		for (; h(e.parent) && e.key === "expression";) e = e.parentPath;
+		let t = e.parent;
+		if ((i.isMemberExpression(t) || i.isOptionalMemberExpression(t)) && e.key === "property" && t.computed) return a(t.object, e.scope) === "map";
+		if (i.isObjectProperty(t) && e.key === "key" && i.isObjectPattern(e.parentPath.parent)) {
+			let t = e.parentPath.parentPath;
+			if (i.isVariableDeclarator(t.parent) && t.key === "id" && t.parent.init) return a(t.parent.init, e.scope) === "map";
+			if (i.isAssignmentExpression(t.parent) && t.key === "left") return a(t.parent.right, e.scope) === "map";
+		}
+		return !1;
+	};
+}
+function v(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 y(e, t, r, i) {
+	let a = n(e, {
+		sourceType: "module",
+		plugins: [
+			"typescript",
+			"jsx",
+			"decorators-legacy"
+		]
+	}), o = _(a, v(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
+//#region src/asset-constants/manifest.ts
+var b = 1 << 20, x = [
+	"image",
+	"image-bg",
+	"image-sprite",
+	"image-icon",
+	"image-tile",
+	"sound",
+	"music",
+	"synth",
+	"model",
+	"animation",
+	"video",
+	"file"
+];
+function S(e) {
+	throw Error(`assets: ${e}`);
+}
+function C(e, t, n = []) {
+	(!e || typeof e != "object" || Array.isArray(e)) && S("object required");
+	let r = e;
+	return Object.keys(r).some((e) => !t.includes(e)) && S("unknown field"), n.some((e) => !(e in r) || r[e] === null) && S("required field missing"), r;
+}
+function w(e, t, n = !1) {
+	(typeof e != "string" || Buffer.byteLength(e) > t || /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f\uFEFF]/.test(e) || n && !e.trim()) && S("invalid bounded text");
+}
+function T(e, t) {
+	(typeof e != "string" || !t.includes(e)) && S("unsupported field value");
+}
+function E(e, t = !1) {
+	(typeof e != "number" || !Number.isFinite(e) || e <= 0 || t && !Number.isInteger(e)) && S("positive dimension/duration required");
+}
+function D(e) {
+	let t = C(e, [
+		"stage",
+		"code",
+		"message",
+		"retryable"
+	], [
+		"stage",
+		"code",
+		"message",
+		"retryable"
+	]);
+	w(t.stage, 128, !0), w(t.code, 128, !0), w(t.message, 4096, !0), typeof t.retryable != "boolean" && S("retryable boolean required");
+}
+function O(e) {
+	return typeof e.schemaVersion == "number";
+}
+function k(e) {
+	let t = 0, n = () => {
+		for (; /\s/.test(e[t] ?? "") && t < e.length;) t++;
+	}, r = () => {
+		let n = t++;
+		for (; t < e.length;) {
+			if (e[t] === "\\") {
+				t += 2;
+				continue;
+			}
+			if (e[t++] === "\"") return JSON.parse(e.slice(n, t));
+		}
+		return S("invalid string");
+	}, i = () => {
+		if (n(), e[t] === "{") {
+			t++, n();
+			let a = /* @__PURE__ */ new Set();
+			for (; e[t] !== "}";) {
+				let o = r();
+				if (a.has(o) && S("duplicate object key"), a.add(o), n(), t++, i(), n(), e[t] !== ",") break;
+				t++, n();
+			}
+			t++;
+		} else if (e[t] === "[") {
+			for (t++, n(); e[t] !== "]" && (i(), n(), e[t] === ",");) t++, n();
+			t++;
+		} else if (e[t] === "\"") r();
+		else for (; t < e.length && !/[\s,\]}]/.test(e[t]);) t++;
+	};
+	i();
+}
+function A(e) {
+	(!e || Buffer.byteLength(e) > b) && S("invalid document size");
+	let t;
+	try {
+		t = JSON.parse(e);
+	} catch {
+		S("invalid JSON syntax");
+	}
+	k(e);
+	let n = C(t, Object.keys(t));
+	if (!("schemaVersion" in n)) return Object.values(n).some((e) => typeof e != "string") && S("legacy inventory must contain URLs"), n;
+	C(n, [
+		"schemaVersion",
+		"artStyle",
+		"assets",
+		"planningError"
+	], [
+		"schemaVersion",
+		"artStyle",
+		"assets"
+	]), n.schemaVersion !== 1 && S("unsupported schema version"), w(n.artStyle, 2048), n.planningError !== void 0 && (D(n.planningError), n.planningError.stage !== "planning" && S("planningError stage must be planning"));
+	let r = C(n.assets, Object.keys(n.assets ?? {}));
+	for (let [e, t] of Object.entries(r)) {
+		w(e, 256, !0);
+		let n = C(t, [
+			"type",
+			"source",
+			"replaceable",
+			"description",
+			"params",
+			"generation",
+			"status",
+			"url",
+			"output",
+			"error",
+			"implementation"
+		], [
+			"type",
+			"source",
+			"replaceable",
+			"description",
+			"status"
+		]);
+		if (T(n.type, x), T(n.source, [
+			"generated",
+			"user",
+			"existing",
+			"code"
+		]), (typeof n.replaceable != "boolean" || n.replaceable !== (n.source !== "code")) && S("source/replaceable mismatch"), w(n.description, 4096, !0), T(n.status, [
+			"planned",
+			"ready",
+			"failed",
+			"skipped",
+			"degraded"
+		]), n.source === "generated") {
+			String(n.type).startsWith("image") || n.type === "sound" || n.type === "music" || S("unsupported generation type");
+			let e = C(n.generation, ["action", "prompt"], ["action", "prompt"]);
+			T(e.action, ["generate", "reuse"]), w(e.prompt, 4096, !0);
+		} else n.generation !== void 0 && S("non-generated assets cannot contain generation");
+		if ((n.type === "synth" || n.type === "animation") && n.source !== "code" && S("type requires code source"), n.url !== void 0 && (w(n.url, 4096), (typeof n.url != "string" || !j(n.url)) && S("invalid resource reference")), (n.source === "user" || n.source === "existing") && (!n.url || n.status !== "ready") && S("existing resource requires ready URL"), n.source === "generated" && n.status === "ready" && !n.url && S("ready media requires URL"), n.status === "degraded" && (n.source !== "generated" || !n.url || !n.error) && S("degraded media requires temporary URL and reason"), n.params !== void 0) {
+			let e = C(n.params, [
+				"width",
+				"height",
+				"durationSeconds",
+				"loop"
+			]);
+			for (let t of ["width", "height"]) e[t] !== void 0 && E(e[t], !0);
+			e.durationSeconds !== void 0 && E(e.durationSeconds), e.loop !== void 0 && typeof e.loop != "boolean" && S("loop boolean required");
+		}
+		if (n.output !== void 0) {
+			let e = C(n.output, [
+				"format",
+				"width",
+				"height",
+				"durationSeconds"
+			]);
+			e.format !== void 0 && w(e.format, 32);
+			for (let t of ["width", "height"]) e[t] !== void 0 && E(e[t], !0);
+			e.durationSeconds !== void 0 && E(e.durationSeconds);
+		}
+		if (n.error !== void 0 && D(n.error), n.implementation !== void 0) {
+			let e = C(n.implementation, [
+				"method",
+				"description",
+				"status",
+				"path",
+				"symbol"
+			], [
+				"method",
+				"description",
+				"status"
+			]);
+			T(e.method, [
+				"svg",
+				"canvas",
+				"css",
+				"synth",
+				"animation",
+				"three"
+			]), T(e.status, ["planned", "ready"]), w(e.description, 4096, !0), e.path !== void 0 && w(e.path, 4096), e.symbol !== void 0 && w(e.symbol, 256), e.status === "ready" && !e.path && !e.symbol && S("ready implementation requires path or symbol"), n.source === "code" && n.status !== e.status && S("code status mismatch");
+		}
+		n.source === "code" && (!n.implementation || n.url || n.output || n.error || !["planned", "ready"].includes(String(n.status))) && S("code requires implementation without media result");
+	}
+	return n;
+}
+function j(e) {
+	if (!e || e.trim() !== e || /[\r\n\t\\]/.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)) return !0;
+	if (!/^https?:\/\//i.test(e)) return !1;
+	try {
+		let t = e.slice(e.indexOf("://") + 3).split(/[/?#]/, 1)[0];
+		if (!t || t.includes("%")) return !1;
+		let n = new URL(e);
+		return ["http:", "https:"].includes(n.protocol) && !!n.hostname && !n.username && !n.password;
+	} catch {
+		return !1;
+	}
+}
+function M(e) {
+	return O(e) ? Object.fromEntries(Object.entries(e.assets).filter(([, e]) => e.replaceable && typeof e.url == "string" && e.url.length > 0).map(([e, t]) => [e, t.url])) : { ...e };
+}
+function N(e) {
+	let t = e.split(/[?#]/)[0].toLowerCase();
+	return /\.(mp3|wav|ogg|m4a|aac|flac)$/.test(t) ? "sound" : /\.(mp4|webm|mov)$/.test(t) ? "video" : /\.(png|jpg|jpeg|gif|svg|webp|avif)$/.test(t) ? "image" : /\.(glb|gltf|obj)$/.test(t) ? "model" : "file";
+}
+//#endregion
+export { m as a, _ as c, l as d, u as f, A as i, f as l, N as n, y as o, c as p, O as r, v as s, M as t, d as u };

package/package.json

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

package/src/asset-constants/assets.schema.json

@@ -0,0 +1,232 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Aippy asset manifest",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "artStyle", "assets"],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "artStyle": { "type": "string" },
+    "planningError": {
+      "allOf": [
+        { "$ref": "#/$defs/error" },
+        { "properties": { "stage": { "const": "planning" } } }
+      ]
+    },
+    "assets": {
+      "type": "object",
+      "propertyNames": { "minLength": 1 },
+      "additionalProperties": { "$ref": "#/$defs/entry" }
+    }
+  },
+  "$defs": {
+    "error": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["stage", "code", "message", "retryable"],
+      "properties": {
+        "stage": { "type": "string", "minLength": 1 },
+        "code": { "type": "string", "minLength": 1 },
+        "message": { "type": "string", "minLength": 1 },
+        "retryable": { "type": "boolean" }
+      }
+    },
+    "params": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "width": { "type": "integer", "minimum": 1 },
+        "height": { "type": "integer", "minimum": 1 },
+        "durationSeconds": { "type": "number", "exclusiveMinimum": 0 },
+        "loop": { "type": "boolean" }
+      }
+    },
+    "output": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "format": { "type": "string" },
+        "width": { "type": "integer", "minimum": 1 },
+        "height": { "type": "integer", "minimum": 1 },
+        "durationSeconds": { "type": "number", "exclusiveMinimum": 0 }
+      }
+    },
+    "implementation": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["method", "description", "status"],
+      "properties": {
+        "method": {
+          "enum": ["svg", "canvas", "css", "synth", "animation", "three"]
+        },
+        "description": { "type": "string", "minLength": 1 },
+        "status": { "enum": ["planned", "ready"] },
+        "path": { "type": "string" },
+        "symbol": { "type": "string" }
+      },
+      "allOf": [
+        {
+          "if": { "properties": { "status": { "const": "ready" } } },
+          "then": {
+            "anyOf": [
+              {
+                "required": ["path"],
+                "properties": { "path": { "minLength": 1 } }
+              },
+              {
+                "required": ["symbol"],
+                "properties": { "symbol": { "minLength": 1 } }
+              }
+            ]
+          }
+        }
+      ]
+    },
+    "entry": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["type", "source", "replaceable", "description", "status"],
+      "properties": {
+        "type": {
+          "enum": [
+            "image",
+            "image-bg",
+            "image-sprite",
+            "image-icon",
+            "image-tile",
+            "sound",
+            "music",
+            "synth",
+            "model",
+            "animation",
+            "video",
+            "file"
+          ]
+        },
+        "source": { "enum": ["generated", "user", "existing", "code"] },
+        "replaceable": { "type": "boolean" },
+        "description": { "type": "string", "minLength": 1 },
+        "params": { "$ref": "#/$defs/params" },
+        "generation": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["action", "prompt"],
+          "properties": {
+            "action": { "enum": ["generate", "reuse"] },
+            "prompt": { "type": "string", "minLength": 1 }
+          }
+        },
+        "status": {
+          "enum": ["planned", "ready", "failed", "skipped", "degraded"]
+        },
+        "url": { "type": "string" },
+        "output": { "$ref": "#/$defs/output" },
+        "error": { "$ref": "#/$defs/error" },
+        "implementation": { "$ref": "#/$defs/implementation" }
+      },
+      "allOf": [
+        {
+          "if": { "properties": { "source": { "const": "generated" } } },
+          "then": {
+            "required": ["generation"],
+            "properties": {
+              "replaceable": { "const": true },
+              "type": {
+                "enum": [
+                  "image",
+                  "image-bg",
+                  "image-sprite",
+                  "image-icon",
+                  "image-tile",
+                  "sound",
+                  "music"
+                ]
+              }
+            }
+          },
+          "else": { "not": { "required": ["generation"] } }
+        },
+        {
+          "if": { "properties": { "source": { "const": "code" } } },
+          "then": {
+            "required": ["implementation"],
+            "properties": {
+              "replaceable": { "const": false },
+              "status": { "enum": ["planned", "ready"] }
+            },
+            "not": {
+              "anyOf": [
+                { "required": ["url"] },
+                { "required": ["output"] },
+                { "required": ["error"] }
+              ]
+            },
+            "allOf": [
+              {
+                "if": { "properties": { "status": { "const": "ready" } } },
+                "then": {
+                  "properties": {
+                    "implementation": {
+                      "properties": { "status": { "const": "ready" } }
+                    }
+                  }
+                }
+              },
+              {
+                "if": { "properties": { "status": { "const": "planned" } } },
+                "then": {
+                  "properties": {
+                    "implementation": {
+                      "properties": { "status": { "const": "planned" } }
+                    }
+                  }
+                }
+              }
+            ]
+          },
+          "else": { "properties": { "replaceable": { "const": true } } }
+        },
+        {
+          "if": {
+            "properties": { "type": { "enum": ["synth", "animation"] } }
+          },
+          "then": { "properties": { "source": { "const": "code" } } }
+        },
+        {
+          "if": {
+            "properties": { "source": { "enum": ["user", "existing"] } }
+          },
+          "then": {
+            "required": ["url"],
+            "properties": {
+              "url": { "minLength": 1 },
+              "status": { "const": "ready" }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": {
+              "source": { "const": "generated" },
+              "status": { "const": "ready" }
+            }
+          },
+          "then": {
+            "required": ["url"],
+            "properties": { "url": { "minLength": 1 } }
+          }
+        },
+        {
+          "if": { "properties": { "status": { "const": "degraded" } } },
+          "then": {
+            "required": ["url", "error"],
+            "properties": {
+              "source": { "const": "generated" },
+              "url": { "minLength": 1 }
+            }
+          }
+        }
+      ]
+    }
+  }
+}