@generaltranslation/vue-extractor 0.0.0

package/dist/internal/script/jsx.js

@@ -0,0 +1,667 @@
+import { addVueError, babelLocation, createInlineMetadata, unwrapExpression } from "../utils.js";
+import { isAcceptedPluralForm } from "generaltranslation/internal";
+import * as babel from "@babel/types";
+import { HTML_CONTENT_PROPS } from "@generaltranslation/format/types";
+import { isHTMLTag, isSVGTag } from "@vue/shared";
+//#region src/internal/script/jsx.ts
+const RESERVED_T_PROPS = new Set(["key", "ref"]);
+const FORMAT_COMPONENTS = new Set([
+	"Currency",
+	"DateTime",
+	"Num"
+]);
+const NON_BRANCH_PROP_NAMES = new Set([
+	"branch",
+	"class",
+	"key",
+	"locales",
+	"n",
+	"ref",
+	"ref-for",
+	"ref-key",
+	"ref_for",
+	"ref_key",
+	"style",
+	"v-slots",
+	"vSlots"
+]);
+/**
+* Extracts one statically identified gt-vue `T` JSX element.
+*
+* This serializer follows the VNodes emitted by `@vue/babel-plugin-jsx`:
+* fragments are transparent, JSX text uses the plugin's normalization, and
+* arbitrary component slots remain opaque because gt-vue does not execute
+* user slots while calculating a source hash.
+*/
+function extractVueJSXTranslation(path, context, analysis) {
+	if (analysis.customPragma) {
+		addVueError(context, babelLocation(analysis.customPragma.loc), "Found a custom @jsx pragma in a gt-vue JSX translation file", "Use the default Vue JSX VNode factory for files containing gt-vue <T>");
+		return;
+	}
+	const errorCount = context.errors.length;
+	const translationContext = readTranslationContext(path.node.openingElement, path.scope, context, analysis);
+	const source = collapseChildren(serializeChildren(path.node.children, { value: 0 }, path.scope, context, analysis));
+	if (context.errors.length !== errorCount) return;
+	context.results.push({
+		dataFormat: "JSX",
+		source,
+		metadata: createInlineMetadata(context, babelLocation(path.node.loc), translationContext)
+	});
+}
+/** Returns whether the visitor is already covered by an outer serialized T. */
+function isNestedInVueJSXTranslation(path, analysis) {
+	let current = path.parentPath;
+	while (current) {
+		if (current.isJSXElement()) {
+			const element = current.node;
+			const identity = resolveElementIdentity(element.openingElement.name, current.scope, analysis);
+			const containingAttribute = findContainingJSXAttribute(path, current);
+			if (containingAttribute && !(identity?.type === "component" && (identity.name === "Branch" || identity.name === "Plural") && isSlotsAttribute(containingAttribute.node))) return false;
+			if (identity?.type === "component") {
+				if (identity.name === "T") return true;
+				if (identity.name === "Var" || FORMAT_COMPONENTS.has(identity.name)) return false;
+			} else if (identity?.type === "vue-builtin" && (identity.name !== "Fragment" || isTransparentFragment(element.openingElement.name, identity))) {
+				if (identity.name === "Suspense" && containingAttribute && isSlotsAttribute(containingAttribute.node)) return false;
+			} else if (!isLiteralFragment(element.openingElement.name) && !isNativeElement(element.openingElement.name)) return false;
+		}
+		current = current.parentPath;
+	}
+	return false;
+}
+/** Finds an attribute boundary between a nested JSX node and one ancestor. */
+function findContainingJSXAttribute(path, ancestor) {
+	let current = path.parentPath;
+	while (current && current !== ancestor) {
+		if (current.isJSXAttribute() && current.parentPath?.isJSXOpeningElement() && current.parentPath.parentPath === ancestor) return current;
+		current = current.parentPath;
+	}
+}
+function isSlotsAttribute(attribute) {
+	const name = readAttributeName(attribute.name);
+	return name === "v-slots" || name === "vSlots";
+}
+/** Resolves a JSX tag to the identity tracked by the script analyzer. */
+function resolveVueJSXElementIdentity(name, scope, analysis) {
+	return resolveElementIdentity(name, scope, analysis);
+}
+/** Enforces the one supported public shape for a gt-vue variable component. */
+function validateVueJSXVariableComponent(element, component, context) {
+	validateVariableElement(element, component, context);
+}
+function readTranslationContext(element, scope, context, analysis) {
+	let translationContext;
+	let hasContext = false;
+	for (const attribute of element.attributes) {
+		if (attribute.type === "JSXSpreadAttribute") {
+			addVueError(context, babelLocation(attribute.loc), "Found a spread prop on a gt-vue <T> component in JSX", "Pass context as one explicit static context or $context prop");
+			continue;
+		}
+		const name = readAttributeName(attribute.name);
+		if (RESERVED_T_PROPS.has(name)) continue;
+		if (name !== "context" && name !== "$context") {
+			addVueError(context, babelLocation(attribute.loc), `Found unsupported prop "${name}" on a gt-vue <T> component`, "gt-vue <T> currently supports only context");
+			continue;
+		}
+		if (hasContext) {
+			addVueError(context, babelLocation(attribute.loc), "Found duplicate context props on a gt-vue <T> component", "Pass only one context prop");
+			continue;
+		}
+		hasContext = true;
+		const contextExpression = attribute.value?.type === "JSXExpressionContainer" && attribute.value.expression.type !== "JSXEmptyExpression" ? unwrapExpression(attribute.value.expression) : void 0;
+		if (contextExpression?.type === "ConditionalExpression" || contextExpression?.type === "LogicalExpression") {
+			addVueError(context, babelLocation(attribute.loc), "Found conditional context on a gt-vue <T> component", "Use one invariant static context string for this translation");
+			continue;
+		}
+		const value = readJSXAttributePrimitive(attribute, scope, analysis);
+		if (!value.ok || typeof value.value !== "string") {
+			addVueError(context, babelLocation(attribute.loc), "Found a dynamic context on a gt-vue <T> component", "Use a string literal or an immutable static string");
+			continue;
+		}
+		translationContext = value.value;
+	}
+	return translationContext;
+}
+function serializeChildren(children, counter, scope, context, analysis) {
+	const result = [];
+	for (const child of children) for (const serialized of serializeChild(child, counter, scope, context, analysis)) appendSerializedChild(result, serialized);
+	return result;
+}
+function serializeChild(child, counter, scope, context, analysis) {
+	if (child.type === "JSXText") {
+		const text = normalizeJSXText(child.value);
+		return text ? [text] : [];
+	}
+	if (child.type === "JSXElement") return serializeElement(child, counter, scope, context, analysis);
+	if (child.type === "JSXFragment") return serializeChildren(child.children, counter, scope, context, analysis);
+	if (child.type === "JSXSpreadChild") {
+		addVueError(context, babelLocation(child.loc), "Found a spread child inside a gt-vue <T> component in JSX", "Use static JSX children and wrap one runtime value in a gt-vue variable component");
+		return [];
+	}
+	if (child.expression.type === "JSXEmptyExpression") return [];
+	return serializeExpression(child.expression, counter, scope, context, analysis);
+}
+function serializeExpression(input, counter, scope, context, analysis) {
+	const expression = unwrapExpression(input);
+	if (!expression) return [];
+	if (expression.type === "JSXElement") return serializeElement(expression, counter, scope, context, analysis);
+	if (expression.type === "JSXFragment") return serializeChildren(expression.children, counter, scope, context, analysis);
+	if (expression.type === "ArrayExpression") {
+		const result = [];
+		for (const item of expression.elements) {
+			if (!item) continue;
+			if (item.type === "SpreadElement") {
+				addVueError(context, babelLocation(item.loc), "Found a spread array child inside a gt-vue <T> component in JSX", "List each static child explicitly");
+				continue;
+			}
+			for (const serialized of serializeExpression(item, counter, scope, context, analysis)) appendSerializedChild(result, serialized);
+		}
+		return result;
+	}
+	if (expression.type === "ConditionalExpression" || expression.type === "LogicalExpression") {
+		addVueError(context, babelLocation(expression.loc), "Found conditional JSX content inside a gt-vue <T> component", "Move conditional content outside <T>, or use a static Branch or Plural component");
+		return [];
+	}
+	const value = analysis.readStaticPrimitive(expression, scope);
+	if (!value.ok) {
+		addVueError(context, babelLocation(expression.loc), "Found dynamic JSX content inside a gt-vue <T> component", "Wrap runtime values in <Var>, <Num>, <DateTime>, or <Currency>");
+		return [];
+	}
+	return value.value == null || typeof value.value === "boolean" ? [] : [String(value.value)];
+}
+function serializeElement(element, counter, scope, context, analysis) {
+	const name = element.openingElement.name;
+	const identity = resolveElementIdentity(name, scope, analysis);
+	if (isTransparentFragment(name, identity)) return serializeChildren(element.children, counter, scope, context, analysis);
+	counter.value += 1;
+	const id = counter.value;
+	const component = identity?.type === "component" ? identity.name : void 0;
+	validateElementAttributes(element.openingElement, scope, context, analysis);
+	if (component === "T") {
+		addVueError(context, babelLocation(element.loc), "Found a nested gt-vue <T> component inside another <T>", "Split nested translations into sibling <T> components");
+		return [];
+	}
+	if (component === "Var" || component === "Num" || component === "DateTime" || component === "Currency") {
+		validateVariableElement(element, component, context);
+		const variable = component === "Num" ? {
+			name: "n",
+			type: "n"
+		} : component === "DateTime" ? {
+			name: "date",
+			type: "d"
+		} : component === "Currency" ? {
+			name: "cost",
+			type: "c"
+		} : {
+			name: "value",
+			type: "v"
+		};
+		return [{
+			i: id,
+			k: `_gt_${variable.name}_${id}`,
+			v: variable.type
+		}];
+	}
+	if (component === "Branch" || component === "Plural") return [serializeBranchElement(element, id, component, counter, scope, context, analysis)];
+	if (identity?.type === "vue-builtin" && identity.name === "Suspense") return [serializeSuspenseElement(element, id, counter, scope, context, analysis)];
+	if (identity?.type === "vue-builtin" && identity.name === "Fragment") {
+		addVueError(context, babelLocation(element.loc), "Found a renamed Vue Fragment binding inside a gt-vue JSX translation", "Use <>, literal <Fragment>, or a Vue namespace member such as <Vue.Fragment>; the Vue JSX transform compiles renamed Fragment bindings as component slots");
+		return [];
+	}
+	if (identity?.type === "vue-builtin") {
+		addVueError(context, babelLocation(element.loc), `Found unsupported Vue <${identity.name}> content inside a gt-vue JSX translation`, "Move this Vue builtin outside <T>");
+		return [];
+	}
+	if (!identity && isUnboundNonNativeElement(name, scope)) {
+		addVueError(context, babelLocation(element.loc), `Could not determine whether JSX tag <${readElementDisplayName(name) ?? "unknown"}> is a component or custom element`, "Import or locally bind the component, or move the configured custom element outside <T>");
+		return [];
+	}
+	const ordinaryShape = identity ? void 0 : resolveOrdinaryElementShape(name, scope, analysis, /* @__PURE__ */ new Set());
+	if (!identity && !ordinaryShape) {
+		addVueError(context, babelLocation(element.loc), `Could not statically resolve whether JSX tag <${readElementDisplayName(name) ?? "unknown"}> renders an element or component`, "Use a native tag, imported component, defineComponent result, or an immutable tag expression that cannot switch between element and component shapes");
+		return [];
+	}
+	const data = readContentProps(element.openingElement, scope, context, analysis);
+	const tag = ordinaryShape?.tag ?? readElementDisplayName(name);
+	if (!tag) {
+		addVueError(context, babelLocation(element.loc), "Found unsupported namespaced JSX syntax inside a gt-vue <T> component", "Use a native element or a statically imported component");
+		return [];
+	}
+	if (ordinaryShape?.opaque) return [{
+		t: tag,
+		i: id,
+		...Object.keys(data).length > 0 && { d: data }
+	}];
+	const children = serializeChildren(element.children, counter, scope, context, analysis);
+	return [{
+		t: tag,
+		i: id,
+		...Object.keys(data).length > 0 && { d: data },
+		...children.length > 0 && { c: collapseChildren(children) }
+	}];
+}
+/**
+* Serializes Vue Suspense's normalized default content without evaluating its
+* fallback. Vue requires that default slot to resolve to one VNode root; an
+* ambiguous or multi-root shape is rejected before it can hash differently.
+*/
+function serializeSuspenseElement(element, id, counter, scope, context, analysis) {
+	const slots = readJSXSlotLayout(element, scope, context, analysis, "suspense");
+	const directSlot = readDirectSuspenseSlot(element, scope, context, analysis);
+	if (directSlot.present) {
+		slots.defaultChildren = [];
+		slots.defaultSlot = directSlot.slot;
+	}
+	for (const name of slots.namedSlots.keys()) {
+		if (name === "fallback" || name.startsWith("_")) continue;
+		addVueError(context, babelLocation(element.loc), `Found unsupported named slot "${name}" on Vue <Suspense> inside a gt-vue <T> component`, "Use only the default and fallback Suspense slots");
+	}
+	if (slots.defaultSlot) validateSuspenseSlotRoot(slots.defaultSlot, element, context);
+	else validateSuspenseImplicitRoot(slots.defaultChildren, element, context);
+	const children = slots.defaultSlot ? serializeSlotFunction(slots.defaultSlot, counter, context, analysis) : serializeChildren(slots.defaultChildren, counter, scope, context, analysis);
+	const data = readContentProps(element.openingElement, scope, context, analysis);
+	return {
+		t: "Suspense",
+		i: id,
+		...Object.keys(data).length > 0 && { d: data },
+		...children.length > 0 && { c: collapseChildren(children) }
+	};
+}
+/** Reads the unambiguous one-function JSX spelling for a default slot. */
+function readDirectSuspenseSlot(element, scope, context, analysis) {
+	if (hasExplicitAttribute(element.openingElement, "v-slots") || hasExplicitAttribute(element.openingElement, "vSlots")) return { present: false };
+	const children = element.children.filter(isMeaningfulJSXChild);
+	if (children.length !== 1 || children[0]?.type !== "JSXExpressionContainer" || children[0].expression.type === "JSXEmptyExpression") return { present: false };
+	const value = unwrapExpression(children[0].expression);
+	if (!value || value.type !== "ArrowFunctionExpression" && value.type !== "FunctionExpression") return { present: false };
+	if (value.params.length > 0 || value.async || value.generator) {
+		addVueError(context, babelLocation(value.loc), "Found a dynamic or scoped default slot on Vue <Suspense> inside a gt-vue <T> component", "Use a synchronous zero-argument function with static returned content");
+		return { present: true };
+	}
+	return {
+		present: true,
+		slot: {
+			node: value,
+			scope: analysis.scopeForNode(value, scope)
+		}
+	};
+}
+/** Enforces the single-root contract for children wrapped by the JSX plugin. */
+function validateSuspenseImplicitRoot(children, element, context) {
+	const roots = children.filter(isMeaningfulJSXChild);
+	if (roots.length > 1) {
+		addSuspenseRootError(element, context);
+		return;
+	}
+	const root = roots[0];
+	if (root?.type === "JSXExpressionContainer" && root.expression.type !== "JSXEmptyExpression") {
+		const expression = unwrapExpression(root.expression);
+		if (expression?.type !== "JSXElement" && expression?.type !== "JSXFragment") addVueError(context, babelLocation(root.loc), "Could not statically prove the default root of Vue <Suspense> inside a gt-vue <T> component", "Use one JSX element, Fragment, or a static zero-argument default slot");
+	}
+}
+/** Enforces the single-root contract for an explicit static slot function. */
+function validateSuspenseSlotRoot(slot, element, context) {
+	const returned = readStaticSlotReturn(slot);
+	const expression = returned && unwrapExpression(returned);
+	if (expression?.type !== "ArrayExpression") return;
+	const roots = expression.elements.filter(Boolean);
+	if (roots.length > 1 || roots.some((root) => root?.type === "SpreadElement" || root?.type !== "JSXElement" && root?.type !== "JSXFragment")) addSuspenseRootError(element, context);
+}
+/** Reports the stable diagnostic shared by all invalid Suspense root shapes. */
+function addSuspenseRootError(element, context) {
+	addVueError(context, babelLocation(element.loc), "Found more than one or an invalid default root inside Vue <Suspense> within a gt-vue <T> component", "Wrap the Suspense default content in one element or Fragment, or move <T> inside <Suspense>");
+}
+/** Serializes GT-owned Branch and Plural slots with independent ID scopes. */
+function serializeBranchElement(element, id, component, counter, scope, context, analysis) {
+	const slots = readJSXSlotLayout(element, scope, context, analysis);
+	if (component === "Plural" && !hasExplicitAttribute(element.openingElement, "n")) addVueError(context, babelLocation(element.openingElement.loc), "Found a gt-vue <Plural> component without an n prop", "Pass the numeric selector through <Plural n={count} />");
+	const children = slots.defaultSlot ? serializeSlotFunction(slots.defaultSlot, counter, context, analysis) : serializeChildren(slots.defaultChildren, counter, scope, context, analysis);
+	const branches = {};
+	for (const [name, slot] of slots.namedSlots) {
+		if (name.startsWith("_")) continue;
+		if (component === "Plural" && !isAcceptedPluralForm(name)) continue;
+		branches[name] = collapseChildren(serializeSlotFunction(slot, { value: id }, context, analysis));
+	}
+	readBranchAttributeSources(element.openingElement, component, branches, scope, context, analysis);
+	const data = readContentProps(element.openingElement, scope, context, analysis);
+	if (Object.keys(branches).length > 0) {
+		data.b = branches;
+		data.t = component === "Plural" ? "p" : "b";
+	}
+	return {
+		t: component,
+		i: id,
+		...Object.keys(data).length > 0 && { d: data },
+		...children.length > 0 && { c: collapseChildren(children) }
+	};
+}
+/** Reconstructs the slots object emitted by the Vue JSX transform. */
+function readJSXSlotLayout(element, scope, context, analysis, owner = "branch") {
+	const ownerLabel = owner === "suspense" ? "Vue <Suspense>" : "a gt-vue JSX branch component";
+	const vSlots = element.openingElement.attributes.filter((attribute) => attribute.type === "JSXAttribute" && isSlotsAttribute(attribute));
+	if (vSlots.length > 1) addVueError(context, babelLocation(vSlots[1].loc), `Found more than one v-slots prop on ${ownerLabel}`, "Pass one static slots object");
+	const meaningfulChildren = element.children.filter(isMeaningfulJSXChild);
+	const objectSlotChild = vSlots.length === 0 && meaningfulChildren.length === 1 && meaningfulChildren[0]?.type === "JSXExpressionContainer" && meaningfulChildren[0].expression.type !== "JSXEmptyExpression" ? analysis.resolveStaticObject(meaningfulChildren[0].expression, scope) : void 0;
+	if (objectSlotChild) addVueError(context, babelLocation(meaningfulChildren[0]?.loc), "Found Vue object-slot child syntax in a gt-vue JSX translation", "Pass the static slots object through v-slots so extraction is independent of the JSX enableObjectSlots compiler option");
+	const slotsObject = vSlots[0] ? readSlotsAttributeObject(vSlots[0], scope, context, analysis, ownerLabel) : void 0;
+	const namedSlots = /* @__PURE__ */ new Map();
+	let defaultSlot;
+	if (slotsObject) for (const [name, slot] of readStaticSlotObject(slotsObject, context, analysis)) if (name === "default") defaultSlot = slot;
+	else namedSlots.set(name, slot);
+	return {
+		defaultChildren: objectSlotChild ? [] : element.children,
+		...defaultSlot && { defaultSlot },
+		namedSlots
+	};
+}
+function readSlotsAttributeObject(attribute, scope, context, analysis, ownerLabel) {
+	const expression = attribute.value?.type === "JSXExpressionContainer" && attribute.value.expression.type !== "JSXEmptyExpression" ? attribute.value.expression : void 0;
+	const object = expression ? analysis.resolveStaticObject(expression, scope) : void 0;
+	if (!object) addVueError(context, babelLocation(attribute.loc), `Found dynamic v-slots on ${ownerLabel}`, "Use a retained object literal with statically named zero-argument slot functions");
+	return object;
+}
+/** Reads statically named zero-argument functions from one JSX slots object. */
+function readStaticSlotObject(object, context, analysis) {
+	const slots = /* @__PURE__ */ new Map();
+	for (const property of object.node.properties) {
+		if (property.type === "SpreadElement") {
+			addVueError(context, babelLocation(property.loc), "Found a spread in a gt-vue JSX slots object", "List every static slot explicitly");
+			continue;
+		}
+		const name = readStaticObjectKey(property, object.scope, analysis);
+		if (name === void 0) {
+			addVueError(context, babelLocation(property.loc), "Found a dynamic slot name in a gt-vue JSX slots object", "Use a static string slot name");
+			continue;
+		}
+		if (slots.has(name)) {
+			addVueError(context, babelLocation(property.loc), `Found duplicate JSX slot "${name}" in a gt-vue translation`, "Define every slot once");
+			continue;
+		}
+		const value = property.type === "ObjectMethod" ? property : unwrapExpression(property.value);
+		if (!value || value.type !== "ArrowFunctionExpression" && value.type !== "FunctionExpression" && value.type !== "ObjectMethod" || value.params.length > 0 || value.async || value.generator) {
+			addVueError(context, babelLocation(property.loc), `Found a dynamic or scoped JSX slot "${name}" in a gt-vue translation`, "Use a synchronous zero-argument function with static returned content");
+			continue;
+		}
+		slots.set(name, {
+			node: value,
+			scope: analysis.scopeForNode(value, object.scope)
+		});
+	}
+	return slots;
+}
+function serializeSlotFunction(slot, counter, context, analysis) {
+	const returned = readStaticSlotReturn(slot);
+	if (!returned) {
+		addVueError(context, babelLocation(slot.node.loc), "Found a JSX slot with a dynamic function body in a gt-vue translation", "Return static slot content directly from the zero-argument function");
+		return [];
+	}
+	return serializeExpression(returned, counter, slot.scope, context, analysis);
+}
+/** Returns the expression from a slot body that contains only one return. */
+function readStaticSlotReturn(slot) {
+	const body = slot.node.body;
+	if (body.type !== "BlockStatement") return body;
+	const statements = body.body.filter((statement) => statement.type !== "EmptyStatement");
+	return (statements.length === 1 && statements[0]?.type === "ReturnStatement" ? statements[0].argument : void 0) ?? void 0;
+}
+function readStaticObjectKey(property, scope, analysis) {
+	if (!property.computed) {
+		if (property.key.type === "Identifier") return property.key.name;
+		if (property.key.type === "StringLiteral" || property.key.type === "NumericLiteral") return String(property.key.value);
+		return;
+	}
+	const key = analysis.readStaticPrimitive(property.key, scope);
+	return key.ok && (typeof key.value === "string" || typeof key.value === "number") ? String(key.value) : void 0;
+}
+function readBranchAttributeSources(element, component, branches, scope, context, analysis) {
+	const seenBranchProps = /* @__PURE__ */ new Set();
+	for (const attribute of element.attributes) {
+		if (attribute.type !== "JSXAttribute") continue;
+		const name = readAttributeName(attribute.name);
+		if (!isBranchPropName(name) || component === "Plural" && !isAcceptedPluralForm(name)) continue;
+		if (seenBranchProps.has(name)) {
+			addVueError(context, babelLocation(attribute.loc), `Found duplicate branch prop "${name}" on a gt-vue <${component}> component`, "Pass each branch prop once so Vue JSX compiler options cannot change which value is hashed");
+			continue;
+		}
+		seenBranchProps.add(name);
+		if (Object.prototype.hasOwnProperty.call(branches, name)) continue;
+		const value = readJSXAttributePrimitive(attribute, scope, analysis);
+		if (!value.ok) {
+			if (isStaticallyNonBranchAttribute(attribute, scope)) continue;
+			addVueError(context, babelLocation(attribute.loc), `Found dynamic branch prop "${name}" on a gt-vue <${component}> component`, "Use a static primitive branch prop or a static named slot");
+			continue;
+		}
+		branches[name] = value.value == null || typeof value.value === "boolean" ? [] : String(value.value);
+	}
+}
+function isBranchPropName(name) {
+	return !(NON_BRANCH_PROP_NAMES.has(name) || name.startsWith("aria-") || name.startsWith("data-") || /^on[^a-z]/.test(name));
+}
+function isStaticallyNonBranchAttribute(attribute, scope) {
+	const expression = attribute.value?.type === "JSXExpressionContainer" && attribute.value.expression.type !== "JSXEmptyExpression" ? unwrapExpression(attribute.value.expression) : void 0;
+	if (!expression) return false;
+	if (expression.type === "Identifier" && expression.name === "undefined") return !scope.hasBinding("undefined");
+	return expression.type === "ArrayExpression" || expression.type === "ArrowFunctionExpression" || expression.type === "ClassExpression" || expression.type === "FunctionExpression" || expression.type === "JSXElement" || expression.type === "JSXFragment" || expression.type === "NewExpression" || expression.type === "ObjectExpression" || expression.type === "RegExpLiteral" || expression.type === "UnaryExpression" && expression.operator === "void";
+}
+function hasExplicitAttribute(element, name) {
+	return element.attributes.some((attribute) => attribute.type === "JSXAttribute" && readAttributeName(attribute.name) === name);
+}
+function isMeaningfulJSXChild(child) {
+	if (child.type === "JSXText") return normalizeJSXText(child.value) !== "";
+	return !(child.type === "JSXExpressionContainer" && child.expression.type === "JSXEmptyExpression");
+}
+function validateVariableElement(element, component, context) {
+	if (context.validatedVariableComponents.has(element)) return;
+	context.validatedVariableComponents.add(element);
+	const explicitProps = /* @__PURE__ */ new Set();
+	let hasSpread = false;
+	for (const attribute of element.openingElement.attributes) if (attribute.type === "JSXSpreadAttribute") hasSpread = true;
+	else explicitProps.add(readAttributeName(attribute.name));
+	if (hasSpread) addVueError(context, babelLocation(element.openingElement.loc), `Found a spread prop on a gt-vue <${component}> component`, "Pass variable component props explicitly");
+	if (component === "Var") {
+		for (const prop of ["name", "value"]) {
+			if (!explicitProps.has(prop)) continue;
+			addVueError(context, babelLocation(element.openingElement.loc), `Found unsupported ${prop} prop on a gt-vue <Var> component`, "Pass the variable as the default child of <Var>");
+		}
+		return;
+	}
+	if (!explicitProps.has("value")) addVueError(context, babelLocation(element.openingElement.loc), `Found a gt-vue <${component}> component without a value prop`, `Pass the runtime value through <${component} value={value} />`);
+	if (hasMeaningfulChildren(element.children)) addVueError(context, babelLocation(element.loc), `Found children on a gt-vue <${component}> component`, `Use only the required value prop: <${component} value={value} />`);
+}
+function hasMeaningfulChildren(children) {
+	return children.some((child) => {
+		if (child.type === "JSXText") return normalizeJSXText(child.value) !== "";
+		return !(child.type === "JSXExpressionContainer" && child.expression.type === "JSXEmptyExpression");
+	});
+}
+function validateElementAttributes(element, scope, context, analysis) {
+	const seenContentProps = /* @__PURE__ */ new Set();
+	for (const attribute of element.attributes) {
+		if (attribute.type === "JSXSpreadAttribute") {
+			addVueError(context, babelLocation(attribute.loc), "Found a spread prop inside a gt-vue <T> component in JSX", "Pass props by static name so their effect on the translation source is known");
+			continue;
+		}
+		const name = readAttributeName(attribute.name);
+		if (isVueJSXDirectiveName(name) && !isSlotsAttribute(attribute)) {
+			addVueError(context, babelLocation(attribute.loc), `Found Vue JSX directive "${name}" inside a gt-vue <T> component`, "Move the directive outside <T> so the translated VNode source stays static");
+			continue;
+		}
+		if (name === "innerHTML" || name === "textContent") {
+			addVueError(context, babelLocation(attribute.loc), `Found source-shaping prop "${name}" inside a gt-vue <T> component`, "Use static JSX children instead");
+			continue;
+		}
+		if (!Object.values(HTML_CONTENT_PROPS).includes(name)) continue;
+		if (seenContentProps.has(name)) {
+			addVueError(context, babelLocation(attribute.loc), `Found duplicate translatable prop "${name}" inside a gt-vue <T> component`, "Pass each translatable element prop once so Vue JSX compiler options cannot change which value is hashed");
+			continue;
+		}
+		seenContentProps.add(name);
+		if (!readJSXAttributePrimitive(attribute, scope, analysis).ok) addVueError(context, babelLocation(attribute.loc), `Found dynamic translatable prop "${name}" inside a gt-vue <T> component`, "Use a static string for translatable element props");
+	}
+}
+function isVueJSXDirectiveName(name) {
+	return /^v(?:-|[A-Z])/.test(name);
+}
+function readContentProps(element, scope, context, analysis) {
+	const data = {};
+	const entries = Object.entries(HTML_CONTENT_PROPS);
+	for (const attribute of element.attributes) {
+		if (attribute.type !== "JSXAttribute") continue;
+		const name = readAttributeName(attribute.name);
+		const entry = entries.find(([, propName]) => propName === name);
+		if (!entry) continue;
+		const value = readJSXAttributePrimitive(attribute, scope, analysis);
+		if (value.ok && typeof value.value === "string") data[entry[0]] = value.value;
+		else if (!value.ok) {}
+	}
+	return data;
+}
+function readJSXAttributePrimitive(attribute, scope, analysis) {
+	if (!attribute.value) return {
+		ok: true,
+		value: true
+	};
+	if (attribute.value.type === "StringLiteral") return {
+		ok: true,
+		value: normalizeJSXText(attribute.value.value)
+	};
+	if (attribute.value.type !== "JSXExpressionContainer" || attribute.value.expression.type === "JSXEmptyExpression") return { ok: false };
+	return analysis.readStaticPrimitive(attribute.value.expression, scope);
+}
+function resolveElementIdentity(name, scope, analysis) {
+	const expression = jsxNameToExpression(name);
+	return expression ? analysis.resolveKnownValue(expression, scope) : void 0;
+}
+function jsxNameToExpression(name) {
+	if (name.type === "JSXIdentifier") return babel.identifier(name.name);
+	if (name.type === "JSXNamespacedName") return void 0;
+	const object = jsxMemberObjectToExpression(name.object);
+	return object ? babel.memberExpression(object, babel.identifier(name.property.name)) : void 0;
+}
+function jsxMemberObjectToExpression(object) {
+	if (object.type === "JSXIdentifier") return babel.identifier(object.name);
+	const parent = jsxMemberObjectToExpression(object.object);
+	return parent ? babel.memberExpression(parent, babel.identifier(object.property.name)) : void 0;
+}
+function isLiteralFragment(name) {
+	return name.type === "JSXIdentifier" && name.name === "Fragment";
+}
+/** Matches only Fragment spellings the Vue JSX transform keeps transparent. */
+function isTransparentFragment(name, identity) {
+	return isLiteralFragment(name) || identity?.type === "vue-builtin" && identity.name === "Fragment" && name.type === "JSXMemberExpression" && name.property.name === "Fragment";
+}
+/** Detects tags whose VNode type can change with plugin `isCustomElement`. */
+function isUnboundNonNativeElement(name, scope) {
+	if (name.type === "JSXIdentifier") return name.name !== "Fragment" && !isNativeElement(name) && !scope.hasBinding(name.name);
+	if (name.type === "JSXNamespacedName") return true;
+	let object = name.object;
+	while (object.type === "JSXMemberExpression") object = object.object;
+	return !scope.hasBinding(object.name);
+}
+function isNativeElement(name) {
+	return name.type === "JSXIdentifier" && (isHTMLTag(name.name) || isSVGTag(name.name));
+}
+/** Proves whether a non-GT JSX tag is traversable or slot-opaque. */
+function resolveOrdinaryElementShape(name, scope, analysis, seen) {
+	if (isNativeElement(name)) return {
+		opaque: false,
+		tag: name.name
+	};
+	if (name.type === "JSXNamespacedName") return void 0;
+	if (name.type === "JSXMemberExpression") {
+		let root = name.object;
+		while (root.type === "JSXMemberExpression") root = root.object;
+		const binding = scope.getBinding(root.name);
+		return binding?.path.isImportSpecifier() || binding?.path.isImportDefaultSpecifier() || binding?.path.isImportNamespaceSpecifier() ? { opaque: true } : void 0;
+	}
+	const binding = scope.getBinding(name.name);
+	if (!binding) return void 0;
+	if (binding.path.isImportSpecifier() || binding.path.isImportDefaultSpecifier() || binding.path.isImportNamespaceSpecifier() || binding.path.isFunctionDeclaration() || binding.path.isClassDeclaration()) return { opaque: true };
+	const declaration = binding.path.node;
+	return declaration.type === "VariableDeclarator" && declaration.init ? resolveOrdinaryElementExpression(declaration.init, binding.path.scope, analysis, seen) : void 0;
+}
+/** Classifies a retained tag expression without executing application code. */
+function resolveOrdinaryElementExpression(input, scope, analysis, seen) {
+	const expression = unwrapExpression(input);
+	if (!expression || seen.has(expression)) return void 0;
+	const nextSeen = new Set(seen);
+	nextSeen.add(expression);
+	const primitive = analysis.readStaticPrimitive(expression, scope);
+	if (primitive.ok) return typeof primitive.value === "string" ? {
+		opaque: false,
+		tag: primitive.value
+	} : void 0;
+	if (expression.type === "ArrowFunctionExpression" || expression.type === "FunctionExpression" || expression.type === "ClassExpression" || expression.type === "ObjectExpression") return { opaque: true };
+	if (expression.type === "Identifier") {
+		const binding = scope.getBinding(expression.name);
+		if (!binding) return void 0;
+		if (binding.path.isImportSpecifier() || binding.path.isImportDefaultSpecifier() || binding.path.isImportNamespaceSpecifier() || binding.path.isFunctionDeclaration() || binding.path.isClassDeclaration()) return { opaque: true };
+		const declaration = binding.path.node;
+		return declaration.type === "VariableDeclarator" && declaration.init ? resolveOrdinaryElementExpression(declaration.init, binding.path.scope, analysis, nextSeen) : void 0;
+	}
+	if (expression.type === "CallExpression" || expression.type === "OptionalCallExpression") {
+		if (expression.callee.type === "V8IntrinsicIdentifier") return void 0;
+		const callee = analysis.resolveKnownValue(expression.callee, scope);
+		if (callee?.type === "defineComponent") return { opaque: true };
+		const argument = expression.arguments[0];
+		return callee?.type === "identity" && expression.arguments.length === 1 && argument && argument.type !== "SpreadElement" && argument.type !== "ArgumentPlaceholder" ? resolveOrdinaryElementExpression(argument, scope, analysis, nextSeen) : void 0;
+	}
+	if (expression.type === "ConditionalExpression") return mergeOrdinaryElementShapes(resolveOrdinaryElementExpression(expression.consequent, scope, analysis, nextSeen), resolveOrdinaryElementExpression(expression.alternate, scope, analysis, nextSeen));
+	if (expression.type === "LogicalExpression") return mergeOrdinaryElementShapes(resolveOrdinaryElementExpression(expression.left, scope, analysis, nextSeen), resolveOrdinaryElementExpression(expression.right, scope, analysis, nextSeen));
+	if (expression.type === "SequenceExpression") {
+		const last = expression.expressions.at(-1);
+		return last ? resolveOrdinaryElementExpression(last, scope, analysis, nextSeen) : void 0;
+	}
+}
+/** Combines alternate tags only when they preserve traversal semantics. */
+function mergeOrdinaryElementShapes(left, right) {
+	if (!left || !right || left.opaque !== right.opaque) return void 0;
+	return {
+		opaque: left.opaque,
+		...left.tag === right.tag && left.tag !== void 0 && { tag: left.tag }
+	};
+}
+function readElementDisplayName(name) {
+	if (name.type === "JSXIdentifier") return name.name;
+	if (name.type === "JSXNamespacedName") return void 0;
+	const object = readMemberDisplayName(name.object);
+	return object ? `${object}.${name.property.name}` : void 0;
+}
+function readMemberDisplayName(object) {
+	if (object.type === "JSXIdentifier") return object.name;
+	const parent = readMemberDisplayName(object.object);
+	return parent ? `${parent}.${object.property.name}` : void 0;
+}
+function readAttributeName(name) {
+	return name.type === "JSXIdentifier" ? name.name : `${name.namespace.name}:${name.name.name}`;
+}
+/** Mirrors `@vue/babel-plugin-jsx`'s JSX text and string-prop transform. */
+function normalizeJSXText(text) {
+	const lines = text.split(/\r\n|\n|\r/);
+	let lastNonEmptyLine = 0;
+	for (let index = 0; index < lines.length; index += 1) if (/[^ \t]/.test(lines[index])) lastNonEmptyLine = index;
+	let result = "";
+	for (let index = 0; index < lines.length; index += 1) {
+		const isFirstLine = index === 0;
+		const isLastLine = index === lines.length - 1;
+		const isLastNonEmptyLine = index === lastNonEmptyLine;
+		let line = lines[index].replace(/\t/g, " ");
+		if (!isFirstLine) line = line.replace(/^ +/, "");
+		if (!isLastLine) line = line.replace(/ +$/, "");
+		if (!line) continue;
+		if (!isLastNonEmptyLine) line += " ";
+		result += line;
+	}
+	return result;
+}
+function appendSerializedChild(result, child) {
+	const previous = result.at(-1);
+	if (typeof previous === "string" && typeof child === "string") result[result.length - 1] = previous + child;
+	else result.push(child);
+}
+function collapseChildren(children) {
+	return children.length === 1 ? children[0] : children;
+}
+//#endregion
+export { extractVueJSXTranslation, isNestedInVueJSXTranslation, resolveVueJSXElementIdentity, validateVueJSXVariableComponent };
+
+//# sourceMappingURL=jsx.js.map