@generaltranslation/vue-extractor 0.1.0-iris.0 → 0.1.0-iris.1

package/dist/internal/script/analyze.js

@@ -138,7 +138,7 @@ function parseVueScript(source, language, context, templateBindings, exposeToTem
 			const localCallable = resolveCalledFunction(path.node.callee, path.scope, state, /* @__PURE__ */ new Set());
 			const calleePath = readResolvedMemberPath(path.node.callee, path.scope, state);
 			const uncertainTranslationHelper = Boolean(calleePath && pathMayReferenceUncertainTranslationHelper(path.node.callee, calleePath, path.scope, state) && callArgumentsMayProvideTranslationFunction(path.node, path.scope, state));
-			if (!callTarget.definitelyOrdinary && !localCallable && calleePath && (callTarget.possibleStringFunction || uncertainTranslationHelper || templateBindings.uncertainStringFunctions.has(calleePath) || state.analysis.uncertainStringFunctions.has(calleePath) || calleePath.endsWith(".value") && templateBindings.uncertainStringFunctions.has(calleePath.slice(0, -6)))) addVueError(context, consumerLocation, `Could not statically resolve possible gt-vue string function alias "${calleePath}"`, "Use a direct, immutable alias of useGT(), useMessages(), or msg()");
+			if (!callTarget.definitelyOrdinary && !localCallable && calleePath && (callTarget.possibleStringFunction || uncertainTranslationHelper || templateBindings.uncertainStringFunctions.has(calleePath) || state.analysis.uncertainStringFunctions.has(calleePath) || calleePath.endsWith(".value") && templateBindings.uncertainStringFunctions.has(calleePath.slice(0, -6)))) addVueError(context, consumerLocation, `Could not statically resolve possible gt-vue string function alias "${calleePath}"`, "Use a direct, immutable alias of useGT(), useMessages(), msg(), or t()");
 			processForwardedTranslationCalls(path, consumerLocation);
 			return;
 		}
@@ -374,6 +374,7 @@ function recordRuntimeReexport(source, exportNames, importerFile, state) {
 	if ((exportNames.includes("*") ? [
 		...COMPONENT_IMPORTS,
 		"msg",
+		"t",
 		"useGT",
 		"useMessages"
 	] : exportNames).some((name) => resolver.hasGTExportReference(modulePath, name))) state.analysis.hasGTSourceReference = true;
@@ -447,6 +448,7 @@ function recordDynamicImportPattern(pattern, source, scope, importerFile, state)
 			for (const exportName of [
 				...COMPONENT_IMPORTS,
 				"msg",
+				"t",
 				"useGT",
 				"useMessages"
 			]) recordDynamicImportBinding(appendTemplatePath(pattern.name, exportName), exportName, modulePath, state, bindingReferencesNamespaceMember(binding, exportName, state));
@@ -456,11 +458,13 @@ function recordDynamicImportPattern(pattern, source, scope, importerFile, state)
 				state.analysis.uncertainComponents.add(path);
 				state.analysis.uncertainGTComponents.add(path);
 			}
-			for (const name of [
+			const stringFunctions = [
 				"msg",
 				"useGT",
 				"useMessages"
-			]) state.analysis.uncertainStringFunctions.add(appendTemplatePath(pattern.name, name));
+			];
+			if (source === "gt-vue") stringFunctions.push("t");
+			for (const name of stringFunctions) state.analysis.uncertainStringFunctions.add(appendTemplatePath(pattern.name, name));
 		}
 		return;
 	}
@@ -470,14 +474,14 @@ function recordDynamicImportPattern(pattern, source, scope, importerFile, state)
 		const exportedName = readPropertyKey(property);
 		const localName = readPatternIdentifier(property.value);
 		if (exportedName && localName) if (modulePath) recordDynamicImportBinding(localName, exportedName, modulePath, state, importerFile === state.analysis.entryFile);
-		else recordUnresolvedGTShapedBinding(localName, exportedName, state);
+		else recordUnresolvedGTShapedBinding(localName, exportedName, state, source === "gt-vue");
 	}
 	for (const property of pattern.properties) {
 		if (property.type !== "ObjectProperty" || !property.computed) continue;
 		const exportedName = readResolvedPropertyKey(property, scope, state);
 		const localName = readPatternIdentifier(property.value);
 		if (exportedName && localName) if (modulePath) recordDynamicImportBinding(localName, exportedName, modulePath, state, importerFile === state.analysis.entryFile);
-		else recordUnresolvedGTShapedBinding(localName, exportedName, state);
+		else recordUnresolvedGTShapedBinding(localName, exportedName, state, source === "gt-vue");
 	}
 }
 /** Returns whether one namespace binding is used through a static member. */
@@ -678,6 +682,7 @@ function recordLocalNamespaceMembers(localName, modulePath, state, binding) {
 		...resolver.listExportNames(modulePath),
 		...COMPONENT_IMPORTS,
 		"msg",
+		"t",
 		"useGT",
 		"useMessages"
 	]);
@@ -705,27 +710,29 @@ function recordLocalNamespaceMembers(localName, modulePath, state, binding) {
 /** Retains the original gt-vue role hidden by a malformed re-export alias. */
 function recordInvalidGTResolution(localName, resolution, state) {
 	if (resolution.gtExportName === "*") {
-		recordUnresolvedGTNamespace(localName, state);
+		recordUnresolvedGTNamespace(localName, state, true);
 		return;
 	}
 	if (resolution.gtExportName) {
-		recordUnresolvedGTShapedBinding(localName, resolution.gtExportName, state);
+		recordUnresolvedGTShapedBinding(localName, resolution.gtExportName, state, true);
 		return;
 	}
 	state.analysis.uncertainTranslationHelpers.add(localName);
 }
 /** Marks the GT-shaped members of one unresolved namespace path. */
-function recordUnresolvedGTNamespace(localName, state) {
+function recordUnresolvedGTNamespace(localName, state, includeImmediateTranslation = false) {
 	for (const component of COMPONENT_IMPORTS) {
 		const componentPath = appendTemplatePath(localName, component);
 		state.analysis.uncertainComponents.add(componentPath);
 		state.analysis.uncertainGTComponents.add(componentPath);
 	}
-	for (const name of [
+	const stringFunctions = [
 		"msg",
 		"useGT",
 		"useMessages"
-	]) state.analysis.uncertainStringFunctions.add(appendTemplatePath(localName, name));
+	];
+	if (includeImmediateTranslation) stringFunctions.push("t");
+	for (const name of stringFunctions) state.analysis.uncertainStringFunctions.add(appendTemplatePath(localName, name));
 }
 /** Records unresolved roles only when a local export can actually be GT. */
 function recordMaterializedLocalUncertainty(localName, materialized, state, forceKnownValues = false) {
@@ -768,12 +775,12 @@ function recordUncertainTranslationHelperBinding(localName, scope, state) {
 	if (binding) state.uncertainTranslationHelperBindings.add(binding);
 }
 /** Records the conservative GT roles implied by an unresolved export name. */
-function recordUnresolvedGTShapedBinding(localName, exportName, state) {
+function recordUnresolvedGTShapedBinding(localName, exportName, state, includeImmediateTranslation = false) {
 	if (COMPONENT_IMPORTS.has(exportName)) {
 		state.analysis.uncertainComponents.add(localName);
 		state.analysis.uncertainGTComponents.add(localName);
 	}
-	if (exportName === "msg" || exportName === "useGT" || exportName === "useMessages") state.analysis.uncertainStringFunctions.add(localName);
+	if (exportName === "msg" || includeImmediateTranslation && exportName === "t" || exportName === "useGT" || exportName === "useMessages") state.analysis.uncertainStringFunctions.add(localName);
 }
 /** Fails closed when a resolved local export is ambiguous or mutable. */
 function recordAmbiguousLocalBinding(localName, state) {
@@ -1060,6 +1067,7 @@ function exposeKnownValue(localName, value, templateBindings, analysis) {
 	else if (value.type === "namespace" && value.source === "gt-vue") {
 		for (const component of COMPONENT_IMPORTS) templateBindings.components.set(appendTemplatePath(localName, component), component);
 		templateBindings.stringFunctions.set(appendTemplatePath(localName, "msg"), "msg");
+		templateBindings.stringFunctions.set(appendTemplatePath(localName, "t"), "t");
 	} else if (value.type === "namespace" && value.source === "vue") {
 		for (const builtin of VUE_BUILTIN_IMPORTS) templateBindings.vueBuiltins.set(appendTemplatePath(localName, builtin), builtin);
 		templateBindings.identityFunctions.add(appendTemplatePath(localName, "markRaw"));
@@ -1104,6 +1112,7 @@ function exposeUncertainKnownValue(localName, value, uncertainComponents, uncert
 			uncertainGTComponents.add(appendTemplatePath(localName, component));
 		}
 		uncertainStringFunctions.add(appendTemplatePath(localName, "msg"));
+		uncertainStringFunctions.add(appendTemplatePath(localName, "t"));
 	} else if (value.type === "namespace" && value.source === "vue") for (const builtin of VUE_BUILTIN_IMPORTS) uncertainComponents.add(appendTemplatePath(localName, builtin));
 }
 /** Exposes a callable whose return can affect template component identity. */
@@ -1324,21 +1333,28 @@ function collectNamespaceRestMemberCandidates(localName, binding, pattern, value
 		return key !== void 0 ? [key] : [];
 	}));
 	const certain = isSafelyReadContainerBinding(binding, binding.identifier, Number.POSITIVE_INFINITY, true, state);
-	return (namespace.source === "gt-vue" ? [...[...COMPONENT_IMPORTS].map((name) => ({
-		type: "component",
-		name
-	})), {
-		type: "string",
-		kind: "msg"
-	}] : [...VUE_BUILTIN_IMPORTS].map((name) => ({
+	return (namespace.source === "gt-vue" ? [
+		...[...COMPONENT_IMPORTS].map((name) => ({
+			type: "component",
+			name
+		})),
+		{
+			type: "string",
+			kind: "msg"
+		},
+		{
+			type: "string",
+			kind: "t"
+		}
+	] : [...VUE_BUILTIN_IMPORTS].map((name) => ({
 		type: "vue-builtin",
 		name
 	}))).filter((entry) => {
-		const name = entry.type === "component" ? entry.name : entry.type === "string" ? "msg" : entry.name;
+		const name = entry.type === "component" ? entry.name : entry.type === "string" ? entry.kind : entry.name;
 		return !excluded.has(name);
 	}).map((entry) => ({
 		certain,
-		name: appendTemplatePath(localName, entry.type === "component" ? entry.name : entry.type === "string" ? "msg" : entry.name),
+		name: appendTemplatePath(localName, entry.type === "component" ? entry.name : entry.type === "string" ? entry.kind : entry.name),
 		value: entry
 	}));
 }
@@ -2171,13 +2187,12 @@ function resolveKnownExpression(node, scope, state, seen) {
 	if (expression.type === "LogicalExpression") {
 		const left = resolveKnownExpression(expression.left, scope, state, new Set(seen));
 		if (left) return expression.operator === "&&" ? resolveKnownExpression(expression.right, scope, state, new Set(seen)) : left;
-		const staticLeft = readStaticFromScope(expression.left, scope, /* @__PURE__ */ new Set(), expression.left.end ?? Number.POSITIVE_INFINITY, state.analysis);
-		if (!staticLeft.ok) return void 0;
-		return (expression.operator === "??" ? staticLeft.value == null : expression.operator === "||" ? !staticLeft.value : Boolean(staticLeft.value)) ? resolveKnownExpression(expression.right, scope, state, new Set(seen)) : void 0;
+		const selection = readStaticLogicalSelection(expression, scope, state, new Set(seen));
+		return selection ? resolveKnownExpression(expression[selection], scope, state, new Set(seen)) : void 0;
 	}
 	if (expression.type === "ConditionalExpression") {
-		const condition = readStaticFromScope(expression.test, scope, /* @__PURE__ */ new Set(), expression.test.end ?? Number.POSITIVE_INFINITY, state.analysis);
-		if (condition.ok) return resolveKnownExpression(condition.value ? expression.consequent : expression.alternate, scope, state, new Set(seen));
+		const condition = readStaticTruthiness(expression.test, scope, state, new Set(seen));
+		if (condition) return resolveKnownExpression(condition === "truthy" ? expression.consequent : expression.alternate, scope, state, new Set(seen));
 		const consequent = resolveKnownExpression(expression.consequent, scope, state, new Set(seen));
 		const alternate = resolveKnownExpression(expression.alternate, scope, state, new Set(seen));
 		return consequent && alternate && knownValueKey(consequent) === knownValueKey(alternate) ? consequent : void 0;
@@ -3629,6 +3644,31 @@ function bindingMayReferenceStringFunction(binding, state) {
 	if (declaration.type === "VariableDeclarator" && declaration.init && patternMayProduceStringFunction(declaration.id, declaration.init, binding.identifier.name, binding.path.scope, state, new Set([binding]))) return true;
 	return binding.constantViolations.some((violation) => violation.isAssignmentExpression() && patternContains(violation.node.left, binding.identifier.name) && expressionMayProduceStringFunction(violation.node.right, violation.scope, state, new Set([binding])));
 }
+/** Evaluates only side-effect-free truthiness needed for static branch choice. */
+function readStaticTruthiness(node, scope, state, seen) {
+	const expression = unwrapExpression(node);
+	if (!expression) return void 0;
+	const primitive = readStaticFromScope(expression, scope, new Set(seen), expression.end ?? Number.POSITIVE_INFINITY, state.analysis);
+	if (primitive.ok) {
+		if (primitive.value == null) return "nullish";
+		return primitive.value ? "truthy" : "falsy";
+	}
+	if (expression.type === "ConditionalExpression" || expression.type === "LogicalExpression") return;
+	if (resolveKnownExpression(expression, scope, state, new Set(seen))) return "truthy";
+	if (expression.type === "ArrayExpression" || expression.type === "ArrowFunctionExpression" || expression.type === "ClassExpression" || expression.type === "FunctionExpression" || expression.type === "ObjectExpression" || expression.type === "RegExpLiteral") return "truthy";
+	if (expression.type === "Identifier") {
+		const binding = scope.getBinding(expression.name);
+		if (!binding) return expression.name !== "undefined" && ORDINARY_GLOBAL_VALUES.has(expression.name) ? "truthy" : void 0;
+		if (!binding.constant || seen.has(binding)) return void 0;
+		if (binding.path.isClassDeclaration() || binding.path.isFunctionDeclaration()) return "truthy";
+	}
+}
+/** Selects a logical branch when the left value's truthiness is static. */
+function readStaticLogicalSelection(expression, scope, state, seen = /* @__PURE__ */ new Set()) {
+	const value = readStaticTruthiness(expression.left, scope, state, seen);
+	if (!value) return void 0;
+	return (expression.operator === "??" ? value === "nullish" : expression.operator === "||" ? value !== "truthy" : value === "truthy") ? "right" : "left";
+}
 /** Tracks expressions whose resulting value can be a gt-vue string function. */
 function expressionMayProduceStringFunction(node, scope, state, seen) {
 	if (state.analysis.stats) state.analysis.stats.stringFunctionVisits += 1;
@@ -3667,8 +3707,16 @@ function expressionMayProduceStringFunction(node, scope, state, seen) {
 		}
 		return expression.arguments.some((argument) => argument.type !== "ArgumentPlaceholder" && (expressionMayProduceStringFunction(argument.type === "SpreadElement" ? argument.argument : argument, scope, state, seen) || containerMayContainStringFunction(argument.type === "SpreadElement" ? argument.argument : argument, scope, state, /* @__PURE__ */ new Set())));
 	}
-	if (expression.type === "ConditionalExpression") return expressionMayProduceStringFunction(expression.consequent, scope, state, seen) || expressionMayProduceStringFunction(expression.alternate, scope, state, seen);
-	if (expression.type === "LogicalExpression") return expressionMayProduceStringFunction(expression.left, scope, state, seen) || expressionMayProduceStringFunction(expression.right, scope, state, seen);
+	if (expression.type === "ConditionalExpression") {
+		const condition = readStaticTruthiness(expression.test, scope, state, seen);
+		if (condition) return expressionMayProduceStringFunction(condition === "truthy" ? expression.consequent : expression.alternate, scope, state, seen);
+		return expressionMayProduceStringFunction(expression.consequent, scope, state, seen) || expressionMayProduceStringFunction(expression.alternate, scope, state, seen);
+	}
+	if (expression.type === "LogicalExpression") {
+		const selection = readStaticLogicalSelection(expression, scope, state);
+		if (selection) return expressionMayProduceStringFunction(expression[selection], scope, state, seen);
+		return expressionMayProduceStringFunction(expression.left, scope, state, seen) || expressionMayProduceStringFunction(expression.right, scope, state, seen);
+	}
 	if (expression.type === "SequenceExpression") return expressionMayProduceStringFunction(expression.expressions.at(-1), scope, state, seen);
 	if (expression.type === "AssignmentExpression") return expressionMayProduceStringFunction(expression.right, scope, state, seen);
 	if (expression.type === "AwaitExpression" || expression.type === "YieldExpression") return expressionMayProduceStringFunction(expression.argument, scope, state, seen);