@vizejs/vite-plugin-musea 0.429.1 → 0.430.1

package/dist/options-CZYdDtTW.mjs

@@ -0,0 +1,581 @@
+import { E as loadNative, S as resolveTrustedSourcePath, g as assertComponentSourcePath, s as toPascalCase, t as escapeHtml } from "./utils-DeMLVlNS.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+//#region src/component-source.ts
+function allowedSourceRoots(root, scanRoots = []) {
+	return [...new Set([root, ...scanRoots].map((sourceRoot) => path.resolve(sourceRoot)))];
+}
+function resolveReadableArtPath(root, scanRoots, artPath) {
+	return resolveTrustedSourcePath(root, scanRoots, artPath, "art path");
+}
+function resolveComponentSourcePath(art, artPath, sourceRoots) {
+	const componentPath = art.isInline && art.componentPath ? art.componentPath : art.metadata.component ? path.isAbsolute(art.metadata.component) ? art.metadata.component : path.resolve(path.dirname(artPath), art.metadata.component) : null;
+	const [projectRoot, ...extraRoots] = sourceRoots;
+	if (!componentPath) return null;
+	const resolved = resolveTrustedSourcePath(projectRoot ?? ".", extraRoots, componentPath, "component path");
+	assertComponentSourcePath(resolved, "component path");
+	return resolved;
+}
+//#endregion
+//#region src/art-module-vue2.ts
+/**
+* Legacy Vue 2 variant emission.
+*
+* Vue 2 has no `openBlock`/`createElementBlock` runtime, so the compiled Vue 3
+* render functions the SFC pipeline produces cannot load there. Vue 2 galleries
+* keep the runtime-compiled `template:` string they always had — the TypeScript
+* fix in #3857 applies to Vue 3, which is what `.art.vue` with
+* `<script setup lang="ts">` targets.
+*/
+function escapeTemplateLiteral(str) {
+	return str.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
+}
+function emitLegacyVariant(context) {
+	const { variantComponentName, variantName, template, componentTagName, componentBindingName, scriptSetup, hasSetup, isolatedSetup, setupReturn, importDeclaresName } = context;
+	const escapedTemplate = escapeTemplateLiteral(template);
+	const fullTemplate = `<div data-variant="${escapeTemplateLiteral(escapeHtml(variantName))}">${escapedTemplate}</div>`;
+	const componentNames = /* @__PURE__ */ new Map();
+	if (componentTagName) componentNames.set(componentTagName, componentBindingName);
+	if (scriptSetup) {
+		for (const name of scriptSetup.returnNames) if (/^[A-Z]/.test(name) && scriptSetup.imports.some((imp) => importDeclaresName(imp, name))) componentNames.set(name, name);
+	}
+	const components = componentNames.size > 0 ? `  components: { ${[...componentNames].map(([name, value]) => `${JSON.stringify(name)}: ${value}`).join(", ")} },\n` : "";
+	if (scriptSetup && hasSetup && isolatedSetup) return `
+export const ${variantComponentName} = __museaDefineComponent({
+  name: '${variantComponentName}',
+${components}  setup() {
+${scriptSetup.setupBody.join("\n")}
+    return ${setupReturn};
+  },
+  template: \`${fullTemplate}\`,
+});
+`;
+	if (scriptSetup && hasSetup) return `
+export const ${variantComponentName} = __museaDefineComponent({
+  name: '${variantComponentName}',
+${components}  setup() {
+    return __museaSharedSetup;
+  },
+  template: \`${fullTemplate}\`,
+});
+`;
+	return `
+export const ${variantComponentName} = {
+  name: '${variantComponentName}',
+${components}  template: \`${fullTemplate}\`,
+};
+`;
+}
+//#endregion
+//#region src/art-component.ts
+/**
+* Resolve which component an art file demonstrates, and under what tag.
+*
+* Shared by the art module and by the per-variant SFC compiler (#3857) so both
+* agree on the import path, the tag `<Self>` expands to, and the binding name.
+* The parsed `<script setup>` is passed in rather than parsed here, so this
+* module does not have to import back from `art-module.ts`.
+*/
+function componentNameFromSource$1(source) {
+	const withoutQuery = source.split(/[?#]/, 1)[0] || source;
+	const filename = path.basename(withoutQuery);
+	const extension = path.extname(filename);
+	const name = toPascalCase(extension ? filename.slice(0, -extension.length) : filename);
+	return name === "Variant" ? "MuseaComponent" : name;
+}
+function resolveArtComponent(art, filePath, scriptSetup, options = {}) {
+	let componentImportPath;
+	let componentTagName;
+	let componentBindingName = "__MuseaComponent";
+	const defineArtComponentName = scriptSetup?.defineArtComponentName;
+	const defineArtComponentSource = scriptSetup?.defineArtComponentSource;
+	if (art.isInline && art.componentPath) {
+		componentImportPath = options.root ? resolveComponentSourcePath(art, filePath, allowedSourceRoots(options.root, options.scanRoots ?? [])) ?? void 0 : art.componentPath;
+		componentTagName = "MuseaComponent";
+	} else if (defineArtComponentSource || art.metadata.component) {
+		const componentSource = defineArtComponentSource ?? art.metadata.component;
+		if (componentSource) {
+			const sourceArt = componentSource === art.metadata.component ? art : {
+				...art,
+				metadata: {
+					...art.metadata,
+					component: componentSource
+				}
+			};
+			componentImportPath = options.root ? resolveComponentSourcePath(sourceArt, filePath, allowedSourceRoots(options.root, options.scanRoots ?? [])) ?? void 0 : path.isAbsolute(componentSource) ? componentSource : path.resolve(path.dirname(filePath), componentSource);
+		}
+		componentTagName = defineArtComponentName ?? (art.metadata.component ? componentNameFromSource$1(art.metadata.component) : "MuseaComponent");
+		componentBindingName = componentTagName;
+	}
+	return {
+		componentImportPath,
+		componentTagName,
+		componentBindingName
+	};
+}
+/** Expand `<Self>` in a variant template to the resolved component tag. */
+function expandSelfTag(template, componentTagName) {
+	if (!componentTagName) return template;
+	return template.replace(/<Self(?=[\s/>])/g, `<${componentTagName}`).replace(/<\/Self\s*>/g, `</${componentTagName}>`);
+}
+//#endregion
+//#region src/art-module.ts
+/**
+* Art module generation for Musea.
+*
+* Generates the virtual ES modules that represent parsed `.art.vue` files,
+* including variant component definitions and script setup handling.
+*/
+/**
+* Extract the content of the first <script setup> block from a Vue SFC source.
+*/
+function extractScriptSetupContent(source) {
+	return source.match(/<script\s+[^>]*setup[^>]*>([\s\S]*?)<\/script>/)?.[1]?.trim();
+}
+function extractScriptSetupIsolated(source) {
+	const match = source.match(/<script\s+([^>]*)\bsetup\b([^>]*)>/);
+	if (!match) return true;
+	const isolate = `${match[1] ?? ""} ${match[2] ?? ""}`.match(/\bisolate\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/);
+	return (isolate?.[1] ?? isolate?.[2] ?? isolate?.[3]) !== "false";
+}
+function resolveRelativeSpecifier(specifier, artDir) {
+	if (!specifier.startsWith(".")) return specifier;
+	return path.resolve(artDir, specifier);
+}
+function rewriteRelativeImportStatement(statement, artDir) {
+	return statement.replace(/\bfrom\s+(['"])([^'"]+)\1/g, (_match, quote, specifier) => `from ${quote}${resolveRelativeSpecifier(specifier, artDir)}${quote}`).replace(/^(\s*import\s+)(['"])([^'"]+)\2(\s*;?\s*)$/s, (_match, prefix, quote, specifier, suffix) => `${prefix}${quote}${resolveRelativeSpecifier(specifier, artDir)}${quote}${suffix}`);
+}
+function countCharBalance(source, openChar, closeChar) {
+	let balance = 0;
+	for (const char of source) if (char === openChar) balance++;
+	else if (char === closeChar) balance--;
+	return balance;
+}
+function isCompleteImportStatement(statement) {
+	const trimmed = statement.trim();
+	if (!trimmed.startsWith("import ")) return false;
+	if (countCharBalance(statement, "{", "}") > 0) return false;
+	return /^import\s+[\s\S]+?\s+from\s+['"][^'"]+['"]\s*;?$/s.test(trimmed) || /^import\s+['"][^'"]+['"]\s*;?$/s.test(trimmed);
+}
+function splitTopLevelCommaList(source) {
+	const parts = [];
+	let current = "";
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	let parenDepth = 0;
+	for (const char of source) {
+		if (char === "," && braceDepth === 0 && bracketDepth === 0 && parenDepth === 0) {
+			const trimmed = current.trim();
+			if (trimmed) parts.push(trimmed);
+			current = "";
+			continue;
+		}
+		current += char;
+		if (char === "{") braceDepth++;
+		else if (char === "}") braceDepth--;
+		else if (char === "[") bracketDepth++;
+		else if (char === "]") bracketDepth--;
+		else if (char === "(") parenDepth++;
+		else if (char === ")") parenDepth--;
+	}
+	const trimmed = current.trim();
+	if (trimmed) parts.push(trimmed);
+	return parts;
+}
+function collectImportedNames(statement, returnNames) {
+	const fromMatch = statement.replace(/\s+/g, " ").trim().replace(/;$/, "").match(/^import\s+(type\s+)?(.+?)\s+from\s+['"][^'"]+['"]$/);
+	if (!fromMatch) return;
+	if (fromMatch[1]) return;
+	const specifierParts = splitTopLevelCommaList(fromMatch[2].trim());
+	const defaultOrNamespace = specifierParts[0]?.trim() ?? "";
+	const trailing = specifierParts.slice(1).join(", ").trim();
+	if (defaultOrNamespace && !defaultOrNamespace.startsWith("{")) {
+		const namespaceMatch = defaultOrNamespace.match(/^\*\s+as\s+([A-Za-z_$][\w$]*)$/);
+		if (namespaceMatch) returnNames.add(namespaceMatch[1]);
+		else if (!defaultOrNamespace.startsWith("type ")) returnNames.add(defaultOrNamespace);
+	}
+	const namedBlock = defaultOrNamespace.startsWith("{") ? defaultOrNamespace : trailing.startsWith("{") ? trailing : "";
+	if (!namedBlock) return;
+	const namedContent = namedBlock.slice(1, -1);
+	for (const part of splitTopLevelCommaList(namedContent)) {
+		const trimmed = part.trim();
+		if (!trimmed || trimmed.startsWith("type ")) continue;
+		const alias = trimmed.split(/\s+as\s+/).pop()?.trim();
+		if (alias) returnNames.add(alias);
+	}
+}
+function importDeclaresName(statement, name) {
+	const names = /* @__PURE__ */ new Set();
+	collectImportedNames(statement, names);
+	return names.has(name);
+}
+function collectObjectDestructuredNames(statement, returnNames) {
+	const match = statement.match(/^(?:export\s+)?(?:const|let|var)\s+\{([\s\S]*?)\}\s*=/);
+	if (!match) return;
+	for (const part of splitTopLevelCommaList(match[1])) {
+		let name = part.trim();
+		if (!name) continue;
+		if (name.startsWith("...")) name = name.slice(3).trim();
+		else if (name.includes(":")) name = name.split(":").pop().trim();
+		else if (name.includes("=")) name = name.split("=")[0].trim();
+		if (name.includes("=")) name = name.split("=")[0].trim();
+		if (/^[A-Za-z_$][\w$]*$/.test(name)) returnNames.add(name);
+	}
+}
+function collectArrayDestructuredNames(statement, returnNames) {
+	const match = statement.match(/^(?:export\s+)?(?:const|let|var)\s+\[([\s\S]*?)\]\s*=/);
+	if (!match) return;
+	for (const part of splitTopLevelCommaList(match[1])) {
+		let name = part.trim();
+		if (!name) continue;
+		if (name.startsWith("...")) name = name.slice(3).trim();
+		if (name.includes("=")) name = name.split("=")[0].trim();
+		if (/^[A-Za-z_$][\w$]*$/.test(name)) returnNames.add(name);
+	}
+}
+function collectTopLevelReturnNames(setupBody, returnNames) {
+	let braceDepth = 0;
+	for (let i = 0; i < setupBody.length; i++) {
+		const line = setupBody[i];
+		const trimmed = line.trim();
+		if (braceDepth === 0) {
+			if (/^(?:export\s+)?(?:const|let|var)\s+\{/.test(trimmed)) {
+				const statementLines = [line];
+				let balance = countCharBalance(line, "{", "}") + countCharBalance(line, "[", "]") + countCharBalance(line, "(", ")");
+				while (balance > 0 && i + 1 < setupBody.length) {
+					i++;
+					statementLines.push(setupBody[i]);
+					balance += countCharBalance(setupBody[i], "{", "}") + countCharBalance(setupBody[i], "[", "]") + countCharBalance(setupBody[i], "(", ")");
+				}
+				collectObjectDestructuredNames(statementLines.join("\n"), returnNames);
+				continue;
+			}
+			if (/^(?:export\s+)?(?:const|let|var)\s+\[/.test(trimmed)) {
+				const statementLines = [line];
+				let balance = countCharBalance(line, "{", "}") + countCharBalance(line, "[", "]") + countCharBalance(line, "(", ")");
+				while (balance > 0 && i + 1 < setupBody.length) {
+					i++;
+					statementLines.push(setupBody[i]);
+					balance += countCharBalance(setupBody[i], "{", "}") + countCharBalance(setupBody[i], "[", "]") + countCharBalance(setupBody[i], "(", ")");
+				}
+				collectArrayDestructuredNames(statementLines.join("\n"), returnNames);
+				continue;
+			}
+			const constMatch = trimmed.match(/^(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)/);
+			if (constMatch) returnNames.add(constMatch[1]);
+			const functionMatch = trimmed.match(/^(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/);
+			if (functionMatch) returnNames.add(functionMatch[1]);
+			const classMatch = trimmed.match(/^(?:export\s+)?class\s+([A-Za-z_$][\w$]*)\b/);
+			if (classMatch) returnNames.add(classMatch[1]);
+		}
+		braceDepth += countCharBalance(line, "{", "}");
+	}
+}
+/**
+* Parse script setup content into imports and setup body.
+* Returns the import lines, setup body lines, and all identifiers to expose.
+*/
+function parseScriptSetupForArt(content) {
+	const lines = content.split("\n");
+	const imports = [];
+	const setupBody = [];
+	const returnNames = /* @__PURE__ */ new Set();
+	let currentImport = null;
+	const defineArtComponent = extractDefineArtComponent(content);
+	let defineArtBalance = 0;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (defineArtBalance > 0) {
+			defineArtBalance += countCharBalance(line, "(", ")");
+			continue;
+		}
+		if (currentImport) {
+			currentImport.push(line);
+			const statement = currentImport.join("\n");
+			if (isCompleteImportStatement(statement)) {
+				imports.push(statement);
+				collectImportedNames(statement, returnNames);
+				currentImport = null;
+			}
+			continue;
+		}
+		if (trimmed.startsWith("import ")) {
+			currentImport = [line];
+			const statement = currentImport.join("\n");
+			if (isCompleteImportStatement(statement)) {
+				imports.push(statement);
+				collectImportedNames(statement, returnNames);
+				currentImport = null;
+			}
+			continue;
+		}
+		if (isDefineArtLine(trimmed)) {
+			defineArtBalance = Math.max(0, countCharBalance(line, "(", ")"));
+			continue;
+		}
+		setupBody.push(line);
+	}
+	if (currentImport) {
+		const statement = currentImport.join("\n");
+		imports.push(statement);
+		collectImportedNames(statement, returnNames);
+	}
+	collectTopLevelReturnNames(setupBody, returnNames);
+	returnNames.delete("type");
+	if (defineArtComponent.name) returnNames.delete(defineArtComponent.name);
+	return {
+		imports,
+		setupBody,
+		returnNames: [...returnNames],
+		defineArtComponentName: defineArtComponent.name,
+		defineArtComponentSource: defineArtComponent.source
+	};
+}
+function extractDefineArtComponent(content) {
+	const sourceMatch = content.match(/\bdefineArt\s*\(\s*(['"])([^'"]+)\1/);
+	if (sourceMatch) return {
+		name: componentNameFromSource(sourceMatch[2]),
+		source: sourceMatch[2]
+	};
+	return { name: content.match(/\bdefineArt\s*\(\s*([A-Za-z_$][\w$]*)/)?.[1] };
+}
+function componentNameFromSource(source) {
+	const withoutQuery = source.split(/[?#]/, 1)[0] || source;
+	const filename = path.basename(withoutQuery);
+	const extension = path.extname(filename);
+	const name = toPascalCase(extension ? filename.slice(0, -extension.length) : filename);
+	return name === "Variant" ? "MuseaComponent" : name;
+}
+function isDefineArtLine(trimmed) {
+	return /\bdefineArt\s*\(/.test(trimmed);
+}
+function generateArtModule(art, filePath, options = {}) {
+	let componentImportPath;
+	let componentTagName;
+	let componentBindingName = "__MuseaComponent";
+	const scriptSetup = art.scriptSetupContent ? parseScriptSetupForArt(art.scriptSetupContent) : null;
+	const defineArtComponentName = scriptSetup?.defineArtComponentName;
+	const defineArtComponentSource = scriptSetup?.defineArtComponentSource;
+	if (art.isInline && art.componentPath) {
+		componentImportPath = options.root ? resolveComponentSourcePath(art, filePath, allowedSourceRoots(options.root, options.scanRoots ?? [])) ?? void 0 : art.componentPath;
+		componentTagName = "MuseaComponent";
+	} else if (defineArtComponentSource || art.metadata.component) {
+		const componentSource = defineArtComponentSource ?? art.metadata.component;
+		if (componentSource) {
+			const sourceArt = componentSource === art.metadata.component ? art : {
+				...art,
+				metadata: {
+					...art.metadata,
+					component: componentSource
+				}
+			};
+			componentImportPath = options.root ? resolveComponentSourcePath(sourceArt, filePath, allowedSourceRoots(options.root, options.scanRoots ?? [])) ?? void 0 : path.isAbsolute(componentSource) ? componentSource : path.resolve(path.dirname(filePath), componentSource);
+		}
+		componentTagName = defineArtComponentName ?? (art.metadata.component ? componentNameFromSource(art.metadata.component) : "MuseaComponent");
+		componentBindingName = componentTagName;
+	}
+	const hasSetupBody = scriptSetup?.setupBody.some((line) => line.trim().length > 0) ?? false;
+	const hasSetup = !!scriptSetup && (hasSetupBody || scriptSetup.returnNames.length > 0);
+	let code = `
+// Auto-generated module for: ${path.basename(filePath)}
+`;
+	if (options.vueVersion === 2 && hasSetup) code += `import { defineComponent as __museaDefineComponent } from 'vue';\n`;
+	if (scriptSetup) {
+		const artDir = path.dirname(filePath);
+		for (const imp of scriptSetup.imports) {
+			const resolved = rewriteRelativeImportStatement(imp, artDir);
+			code += `${resolved}\n`;
+		}
+	}
+	if (componentImportPath && componentTagName) {
+		if (!scriptSetup?.imports.some((imp) => importDeclaresName(imp, componentBindingName))) code += `import ${componentBindingName} from ${JSON.stringify(componentImportPath)};\n`;
+		code += `export const __component__ = ${componentBindingName};\n`;
+	}
+	code += `
+export const metadata = ${JSON.stringify(art.metadata)};
+export const variants = ${JSON.stringify(art.variants)};
+export const __styles__ = ${JSON.stringify(art.styleBlocks ?? [])};
+`;
+	const setupReturn = `{ ${scriptSetup?.returnNames.join(", ") ?? ""} }`;
+	const isolatedSetup = art.scriptSetupIsolated !== false;
+	if (scriptSetup && hasSetup && !isolatedSetup) code += `
+const __museaSharedSetup = (() => {
+${scriptSetup.setupBody.join("\n")}
+  return ${setupReturn};
+})();
+`;
+	for (const variant of art.variants) {
+		const variantComponentName = toPascalCase(variant.name);
+		const template = expandSelfTag(variant.template, componentTagName);
+		if (options.vueVersion === 2) {
+			code += emitLegacyVariant({
+				variantComponentName,
+				variantName: variant.name,
+				template,
+				componentTagName,
+				componentBindingName,
+				scriptSetup,
+				hasSetup,
+				isolatedSetup,
+				setupReturn,
+				importDeclaresName
+			});
+			continue;
+		}
+		const variantModuleId = `virtual:musea-variant:${filePath}:${encodeURIComponent(variant.name)}`;
+		code += `
+import ${variantComponentName} from ${JSON.stringify(variantModuleId)};
+export { ${variantComponentName} };
+`;
+	}
+	const defaultVariant = art.variants.find((v) => v.isDefault) || art.variants[0];
+	if (defaultVariant) code += `
+export default ${toPascalCase(defaultVariant.name)};
+`;
+	return code;
+}
+//#endregion
+//#region src/art-style.ts
+function artScopeAttribute(filePath) {
+	return `data-v-${createHash("sha256").update(filePath).digest("hex").slice(0, 8)}`;
+}
+function stampScopeAttribute(template, scopeAttr) {
+	return template.replace(/<([A-Za-z][\w:.-]*)([^<>]*?)>/g, (match, tag, rest) => {
+		if (rest.includes(scopeAttr)) return match;
+		const selfClosing = /\/\s*$/.test(rest);
+		const attrs = selfClosing ? rest.replace(/\/\s*$/, "").trimEnd() : rest.trimEnd();
+		return `<${tag}${`${attrs.length > 0 && !attrs.startsWith(" ") && !attrs.startsWith("\n") ? " " : ""}${attrs}`.trimEnd()} ${scopeAttr}${selfClosing ? " /" : ""}>`;
+	});
+}
+//#endregion
+//#region src/plugin/art-processing.ts
+function extractArtTagAttributes(source) {
+	const artTagMatch = source.match(/<art\b([\s\S]*?)>/i);
+	if (!artTagMatch) return {};
+	const attributes = {};
+	for (const match of artTagMatch[1].matchAll(/([^\s=/>]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'))?/g)) {
+		const name = match[1];
+		if (!name || name === "/") continue;
+		attributes[name] = match[2] ?? match[3] ?? true;
+	}
+	return attributes;
+}
+function parseActionEvents(value) {
+	if (typeof value !== "string") return void 0;
+	const events = value.split(",").map((eventName) => eventName.trim().toLowerCase()).filter(Boolean);
+	return events.length > 0 ? [...new Set(events)] : void 0;
+}
+function extractCustomArtMetadata(source) {
+	const attrs = extractArtTagAttributes(source);
+	const actionEvents = new Set(parseActionEvents(attrs["action-events"]) ?? []);
+	const captureMousemove = attrs["capture-mousemove"];
+	if (captureMousemove === true || captureMousemove === "true") actionEvents.add("mousemove");
+	return { actionEvents: actionEvents.size > 0 ? [...actionEvents] : void 0 };
+}
+function extractStyleBlocks(source, filePath) {
+	const styles = [];
+	for (const match of source.matchAll(/<style\b([^>]*)>([\s\S]*?)<\/style>/gi)) {
+		const attrs = match[1] ?? "";
+		const content = match[2]?.trim();
+		const lang = attrs.match(/\blang\s*=\s*["']([^"']+)["']/i)?.[1]?.toLowerCase();
+		if (!content) continue;
+		if (lang && lang !== "css") {
+			console.warn(`[musea] ${filePath}: <style lang="${lang}"> is not processed. Art styles are plain CSS.`);
+			continue;
+		}
+		styles.push({
+			content,
+			scoped: /\bscoped\b/i.test(attrs)
+		});
+	}
+	if (!styles.some((style) => style.scoped)) return { blocks: styles.map((style) => style.content) };
+	const scopeAttr = artScopeAttribute(filePath);
+	const scope = loadNative().scopeViteCssForPipeline;
+	return {
+		scopeAttr,
+		blocks: styles.map((style) => style.scoped && scope ? scope(style.content, scopeAttr) : style.content)
+	};
+}
+function formatArtProcessingError(root, filePath, error) {
+	const detail = error instanceof Error ? error.message || error.name : error == null ? "unknown error" : stringifyUnknown(error);
+	return `[musea] Failed to process ${path.relative(root, filePath) || filePath}: ${detail}`;
+}
+function stringifyUnknown(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return value.toString();
+	try {
+		return JSON.stringify(value) ?? "unknown error";
+	} catch {
+		return "unknown error";
+	}
+}
+function reportArtStatusWarnings(binding, source, filename, warn = console.warn) {
+	const warnings = binding.parseArtStatusWarnings?.(source, { filename });
+	if (warnings == null) return;
+	for (const warning of warnings) warn(`[musea] ${warning}`);
+}
+async function processMuseaArtFile(filePath, ctx) {
+	try {
+		const source = await fs.promises.readFile(filePath, "utf-8");
+		const binding = loadNative();
+		const parsed = binding.parseArt(source, { filename: filePath });
+		reportArtStatusWarnings(binding, source, filePath);
+		const customMetadata = extractCustomArtMetadata(source);
+		if (!parsed.variants || parsed.variants.length === 0) return null;
+		const isInline = !filePath.endsWith(".art.vue");
+		const styles = isInline ? { blocks: [] } : extractStyleBlocks(source, filePath);
+		return {
+			path: filePath,
+			metadata: {
+				title: parsed.metadata.title || (isInline ? path.basename(filePath, ".vue") : ""),
+				description: parsed.metadata.description,
+				component: isInline ? void 0 : parsed.metadata.component,
+				category: parsed.metadata.category,
+				tags: parsed.metadata.tags,
+				status: parsed.metadata.status,
+				order: parsed.metadata.order,
+				actionEvents: customMetadata.actionEvents ?? parsed.metadata.actionEvents
+			},
+			variants: parsed.variants.map((v) => ({
+				name: v.name,
+				template: styles.scopeAttr ? stampScopeAttribute(v.template, styles.scopeAttr) : v.template,
+				isDefault: v.isDefault,
+				skipVrt: v.skipVrt
+			})),
+			hasScriptSetup: isInline ? false : parsed.hasScriptSetup,
+			scriptSetupContent: !isInline && parsed.hasScriptSetup ? extractScriptSetupContent(source) : void 0,
+			scriptSetupIsolated: !isInline && parsed.hasScriptSetup ? extractScriptSetupIsolated(source) : true,
+			hasScript: parsed.hasScript,
+			styleCount: parsed.styleCount,
+			styleBlocks: styles.blocks,
+			isInline,
+			componentPath: isInline ? filePath : void 0
+		};
+	} catch (error) {
+		const message = formatArtProcessingError(ctx.root, filePath, error);
+		if (ctx.command === "build") throw new Error(message);
+		(ctx.onError ?? console.error)(message);
+		return null;
+	}
+}
+//#endregion
+//#region src/plugin/options.ts
+const MUSEA_OPTIONS_KEY = "__vizeMuseaOptions";
+function attachMuseaOptions(plugin, options) {
+	Object.defineProperty(plugin, MUSEA_OPTIONS_KEY, {
+		configurable: false,
+		enumerable: false,
+		value: options,
+		writable: false
+	});
+	return plugin;
+}
+function readMuseaOptions(plugin) {
+	if (!plugin || typeof plugin !== "object") return void 0;
+	return plugin[MUSEA_OPTIONS_KEY];
+}
+//#endregion
+export { parseScriptSetupForArt as a, resolveArtComponent as c, resolveReadableArtPath as d, generateArtModule as i, allowedSourceRoots as l, readMuseaOptions as n, rewriteRelativeImportStatement as o, processMuseaArtFile as r, expandSelfTag as s, attachMuseaOptions as t, resolveComponentSourcePath as u };
+
+//# sourceMappingURL=options-CZYdDtTW.mjs.map