@intlayer/babel 9.0.0-canary.9 → 9.0.1

package/dist/esm/babel-plugin-intlayer-usage-analyzer.mjs

@@ -5,7 +5,7 @@ const createPruneContext = () => ({
 	hasUnparsableSourceFiles: false,
 	dictionaryKeysWithUntrackedBindings: /* @__PURE__ */ new Map(),
 	dictionaryKeyToFieldRenameMap: /* @__PURE__ */ new Map(),
-	dictionaryKeysWithOpaqueTopLevelFields: /* @__PURE__ */ new Map(),
+	dictionaryKeysWithOpaqueFields: /* @__PURE__ */ new Map(),
 	dictionariesSkippingFieldRename: /* @__PURE__ */ new Set(),
 	pendingFrameworkAnalysis: /* @__PURE__ */ new Map()
 });
@@ -35,8 +35,11 @@ const recordFieldUsage = (pruneContext, dictionaryKey, fieldUsage) => {
 		pruneContext.dictionaryKeyToFieldUsageMap.set(dictionaryKey, "all");
 		return;
 	}
-	const mergedFieldSet = existingUsage instanceof Set ? new Set([...existingUsage, ...fieldUsage]) : new Set(fieldUsage);
-	pruneContext.dictionaryKeyToFieldUsageMap.set(dictionaryKey, mergedFieldSet);
+	if (existingUsage instanceof Set) {
+		for (const fieldName of fieldUsage) existingUsage.add(fieldName);
+		return;
+	}
+	pruneContext.dictionaryKeyToFieldUsageMap.set(dictionaryKey, new Set(fieldUsage));
 };
 /**
 * Analyses how the result of a single `useIntlayer('key')` / `getIntlayer('key')`
@@ -57,14 +60,18 @@ const analyzeCallExpressionUsage = (babelTypes, pruneContext, callExpressionPath
 		if (!existingPaths.includes(currentSourceFilePath)) pruneContext.dictionaryKeysWithUntrackedBindings.set(dictionaryKey, [...existingPaths, currentSourceFilePath]);
 		recordFieldUsage(pruneContext, dictionaryKey, "all");
 	};
-	/** Record that a field value is consumed opaquely (not further destructured). */
-	const markOpaqueField = (fieldName, line) => {
-		const fieldToLocations = pruneContext.dictionaryKeysWithOpaqueTopLevelFields.get(dictionaryKey) ?? /* @__PURE__ */ new Map();
+	/** Record that the content value at `fieldPath` is consumed opaquely. */
+	const markOpaqueField = (fieldPath, line) => {
+		const pathToOccurrence = pruneContext.dictionaryKeysWithOpaqueFields.get(dictionaryKey) ?? /* @__PURE__ */ new Map();
 		const location = line !== void 0 ? `${currentSourceFilePath}:${line}` : currentSourceFilePath;
-		const locations = fieldToLocations.get(fieldName) ?? [];
-		if (!locations.includes(location)) locations.push(location);
-		fieldToLocations.set(fieldName, locations);
-		pruneContext.dictionaryKeysWithOpaqueTopLevelFields.set(dictionaryKey, fieldToLocations);
+		const joinedFieldPath = fieldPath.join(".");
+		const occurrence = pathToOccurrence.get(joinedFieldPath) ?? {
+			fieldPath: [...fieldPath],
+			locations: []
+		};
+		if (!occurrence.locations.includes(location)) occurrence.locations.push(location);
+		pathToOccurrence.set(joinedFieldPath, occurrence);
+		pruneContext.dictionaryKeysWithOpaqueFields.set(dictionaryKey, pathToOccurrence);
 	};
 	/** Register a plain variable binding in an SFC file for a second-pass analysis. */
 	const deferFrameworkAnalysis = (variableName) => {
@@ -76,37 +83,101 @@ const analyzeCallExpressionUsage = (babelTypes, pruneContext, callExpressionPath
 		pruneContext.pendingFrameworkAnalysis.set(currentSourceFilePath, existing);
 	};
 	/**
-	* Analyses usage of a variable or member access to detect opaque
-	* consumption (passing a dictionary field as-is to a prop or function).
+	* Analyses how the content value at `fieldPath` (currently referenced by
+	* `refPath`) is consumed, to detect opaque consumption (passing a dictionary
+	* value as-is to a prop or function argument).
 	*
-	* If a direct, non-chained consumption is found, it calls `markOpaqueField`.
-	* Chained accesses (e.g. `field.sub`) are NOT considered opaque for `field`
-	* because the renamer can safely track and update them.
+	* Member-access chains and destructuring are followed recursively with an
+	* extended field path, so the *terminal* consumption of a chain like
+	* `content.sections.hero` decides opacity — mirroring how far the
+	* source-code renamer can rewrite accesses. When the terminal consumption
+	* escapes static tracking, the deepest reached field path is marked opaque
+	* so the children of that value keep their original key names.
 	*/
-	const analyzeOpaqueUsage = (refPath, fieldName) => {
+	const analyzeOpaqueUsage = (refPath, fieldPath) => {
 		const parentNode = refPath.parent;
-		if ((babelTypes.isMemberExpression(parentNode) || babelTypes.isOptionalMemberExpression(parentNode)) && parentNode.object === refPath.node) return;
-		if (babelTypes.isVariableDeclarator(parentNode) && babelTypes.isObjectPattern(parentNode.id) && parentNode.init === refPath.node) return;
+		const parentPath = refPath.parentPath;
+		if (parentPath && (babelTypes.isMemberExpression(parentNode) || babelTypes.isOptionalMemberExpression(parentNode)) && parentNode.object === refPath.node) {
+			const memberNode = parentNode;
+			if (memberNode.computed && babelTypes.isNumericLiteral(memberNode.property)) {
+				analyzeOpaqueUsage(parentPath, fieldPath);
+				return;
+			}
+			if (!memberNode.computed && babelTypes.isIdentifier(memberNode.property)) {
+				analyzeOpaqueUsage(parentPath, [...fieldPath, memberNode.property.name]);
+				return;
+			}
+			if (memberNode.computed && babelTypes.isStringLiteral(memberNode.property)) {
+				analyzeOpaqueUsage(parentPath, [...fieldPath, memberNode.property.value]);
+				return;
+			}
+			markOpaqueField(fieldPath, refPath.node.loc?.start.line);
+			return;
+		}
+		if (babelTypes.isVariableDeclarator(parentNode) && babelTypes.isObjectPattern(parentNode.id) && parentNode.init === refPath.node) {
+			analyzeOpaqueDestructuring(parentNode.id, refPath, fieldPath);
+			return;
+		}
 		if (babelTypes.isArrayExpression(parentNode)) return;
-		markOpaqueField(fieldName, refPath.node.loc?.start.line);
+		markOpaqueField(fieldPath, refPath.node.loc?.start.line);
+	};
+	/**
+	* Analyses a destructuring pattern applied to the content value at
+	* `fieldPath`, recursively following each bound local variable's references
+	* via {@link analyzeOpaqueUsage}.
+	*
+	* Patterns the source-code renamer cannot rewrite (rest elements, dynamic
+	* computed keys, array patterns) mark the corresponding path opaque.
+	*/
+	const analyzeOpaqueDestructuring = (objectPattern, scopePath, fieldPath) => {
+		for (const property of objectPattern.properties) {
+			if (babelTypes.isRestElement(property)) {
+				markOpaqueField(fieldPath, property.loc?.start.line);
+				continue;
+			}
+			if (!babelTypes.isObjectProperty(property)) continue;
+			if (property.computed && !babelTypes.isStringLiteral(property.key)) {
+				markOpaqueField(fieldPath, property.loc?.start.line);
+				continue;
+			}
+			const keyName = babelTypes.isIdentifier(property.key) ? property.key.name : babelTypes.isStringLiteral(property.key) ? property.key.value : null;
+			if (!keyName) continue;
+			const childFieldPath = [...fieldPath, keyName];
+			const bindingTarget = babelTypes.isAssignmentPattern(property.value) ? property.value.left : property.value;
+			if (babelTypes.isObjectPattern(bindingTarget)) {
+				analyzeOpaqueDestructuring(bindingTarget, scopePath, childFieldPath);
+				continue;
+			}
+			if (babelTypes.isIdentifier(bindingTarget)) {
+				const localVarBinding = scopePath.scope.getBinding(bindingTarget.name);
+				if (!localVarBinding) continue;
+				for (const referencePath of localVarBinding.referencePaths) analyzeOpaqueUsage(referencePath, childFieldPath);
+				continue;
+			}
+			markOpaqueField(childFieldPath, property.loc?.start.line);
+		}
 	};
 	/**
 	* Helper to collect field names from an ObjectPattern (destructuring).
-	* Returns true if successful, false if a rest element was found (meaning 'all').
+	* Returns true if successful, false when the accessed fields cannot be
+	* determined statically (rest element or dynamic computed key → 'all').
 	*/
 	const collectFieldsFromObjectPattern = (pattern, initPath, targetSet) => {
 		if (pattern.properties.some((prop) => babelTypes.isRestElement(prop))) return false;
 		for (const property of pattern.properties) {
+			if (!babelTypes.isObjectProperty(property)) continue;
+			if (property.computed && !babelTypes.isStringLiteral(property.key)) return false;
 			let fieldName;
-			if (babelTypes.isObjectProperty(property) && babelTypes.isIdentifier(property.key)) fieldName = property.key.name;
-			else if (babelTypes.isObjectProperty(property) && babelTypes.isStringLiteral(property.key)) fieldName = property.key.value;
-			if (fieldName) {
-				targetSet.add(fieldName);
-				if (babelTypes.isObjectProperty(property) && babelTypes.isIdentifier(property.value)) {
-					const variableBinding = initPath.scope.getBinding(property.value.name);
-					if (variableBinding) for (const refPath of variableBinding.referencePaths) analyzeOpaqueUsage(refPath, fieldName);
-				}
-			}
+			if (!property.computed && babelTypes.isIdentifier(property.key)) fieldName = property.key.name;
+			else if (babelTypes.isStringLiteral(property.key)) fieldName = property.key.value;
+			if (!fieldName) continue;
+			targetSet.add(fieldName);
+			const bindingTarget = babelTypes.isAssignmentPattern(property.value) ? property.value.left : property.value;
+			if (babelTypes.isIdentifier(bindingTarget)) {
+				const variableBinding = initPath.scope.getBinding(bindingTarget.name);
+				if (variableBinding) for (const refPath of variableBinding.referencePaths) analyzeOpaqueUsage(refPath, [fieldName]);
+			} else if (babelTypes.isObjectPattern(bindingTarget)) analyzeOpaqueDestructuring(bindingTarget, initPath, [fieldName]);
+			else markOpaqueField([fieldName], property.loc?.start.line);
 		}
 		return true;
 	};
@@ -121,9 +192,9 @@ const analyzeCallExpressionUsage = (babelTypes, pruneContext, callExpressionPath
 		if (!parentNode.computed && babelTypes.isIdentifier(parentNode.property)) fieldName = parentNode.property.name;
 		else if (parentNode.computed && babelTypes.isStringLiteral(parentNode.property)) fieldName = parentNode.property.value;
 		if (fieldName) {
-			recordFieldUsage(pruneContext, dictionaryKey, new Set([fieldName]));
+			recordFieldUsage(pruneContext, dictionaryKey, /* @__PURE__ */ new Set([fieldName]));
 			const memberExprPath = callExpressionPath.parentPath;
-			if (memberExprPath) analyzeOpaqueUsage(memberExprPath, fieldName);
+			if (memberExprPath) analyzeOpaqueUsage(memberExprPath, [fieldName]);
 		} else markUntrackedBinding();
 		return;
 	}
@@ -146,7 +217,7 @@ const analyzeCallExpressionUsage = (babelTypes, pruneContext, callExpressionPath
 				if (fieldName) {
 					accessedTopLevelFieldNames.add(fieldName);
 					const memberExprPath = variableReferencePath.parentPath;
-					if (memberExprPath) analyzeOpaqueUsage(memberExprPath, fieldName);
+					if (memberExprPath) analyzeOpaqueUsage(memberExprPath, [fieldName]);
 				} else {
 					hasUntrackedReferenceAccess = true;
 					break;
@@ -165,7 +236,7 @@ const analyzeCallExpressionUsage = (babelTypes, pruneContext, callExpressionPath
 					if (fieldName) {
 						accessedTopLevelFieldNames.add(fieldName);
 						const memberExprPath = callExprPath?.parentPath;
-						if (memberExprPath) analyzeOpaqueUsage(memberExprPath, fieldName);
+						if (memberExprPath) analyzeOpaqueUsage(memberExprPath, [fieldName]);
 					} else {
 						hasUntrackedReferenceAccess = true;
 						break;
@@ -250,9 +321,9 @@ const readJsxAttributeString = (babelTypes, openingElement, attributeName) => {
 };
 /**
 * Resolves the namespace (dictionary key) for a compat caller call-site from
-* its `CompatNamespaceSource` configuration. Returns the static key, or
-* `'__default__'` when the configured argument is absent (caller falls back to
-* its default namespace), or `undefined` when the value is present but dynamic.
+* one `CallerValueSource`. Returns the static key, or `'__default__'` when the
+* configured argument is absent (caller falls back to its default namespace),
+* or `undefined` when the value is present but dynamic.
 */
 const resolveCompatNamespace = (babelTypes, callArguments, source) => {
 	if (source.from === "fixed") return source.value;
@@ -283,13 +354,28 @@ const resolveCompatNamespace = (babelTypes, callArguments, source) => {
 	return readObjectProperty(babelTypes, optionsArgument, source.property);
 };
 /**
+* Resolves the namespace from a list of `CallerValueSource`s, tried in
+* declaration order. The first source yielding a static string wins.
+* Returns `'__default__'` when every source reports an absent value, and
+* `undefined` when the namespace is present somewhere but dynamic.
+*/
+const resolveNamespaceFromSources = (babelTypes, callArguments, sources) => {
+	let sawAbsentValue = false;
+	for (const source of sources) {
+		const resolved = resolveCompatNamespace(babelTypes, callArguments, source);
+		if (typeof resolved === "string" && resolved !== "__default__") return resolved;
+		if (resolved === "__default__") sawAbsentValue = true;
+	}
+	return sawAbsentValue ? "__default__" : void 0;
+};
+/**
 * Resolves an optional `keyPrefix` for a compat caller. Returns the static
 * prefix string, `null` when no prefix is configured/present, or `undefined`
 * when a prefix is present but dynamic.
 */
-const resolveCompatKeyPrefix = (babelTypes, callArguments, source) => {
-	if (!source) return null;
-	const resolved = resolveCompatNamespace(babelTypes, callArguments, source);
+const resolveCompatKeyPrefix = (babelTypes, callArguments, sources) => {
+	if (!sources || sources.length === 0) return null;
+	const resolved = resolveNamespaceFromSources(babelTypes, callArguments, sources);
 	if (resolved === "__default__") return null;
 	return resolved;
 };
@@ -315,8 +401,8 @@ const unwrapAwait = (babelTypes, path) => {
 * so renaming the compiled JSON keys would break runtime lookups. Pruning
 * (top-level field removal) remains safe because it preserves field names.
 */
-const analyzeNamespaceCallerUsage = (babelTypes, pruneContext, callArguments, callerConfig, isSfcFile, callExpressionPath) => {
-	const resolvedNamespace = resolveCompatNamespace(babelTypes, callArguments, callerConfig.namespace);
+const analyzeNamespaceCallerUsage = (babelTypes, pruneContext, callArguments, callerConfig, isSfcFile, currentSourceFilePath, callExpressionPath, namespaceOverride) => {
+	const resolvedNamespace = namespaceOverride ?? resolveNamespaceFromSources(babelTypes, callArguments, callerConfig.namespaceSources);
 	if (resolvedNamespace === void 0) return;
 	const namespaceString = resolvedNamespace === "__default__" ? DEFAULT_COMPAT_NAMESPACE : resolvedNamespace;
 	const namespaceSegments = namespaceString.split(".");
@@ -331,13 +417,18 @@ const analyzeNamespaceCallerUsage = (babelTypes, pruneContext, callArguments, ca
 		recordFieldUsage(pruneContext, dictionaryKey, "all");
 		return;
 	}
+	if (callerConfig.translationFunction === "content") {
+		if (callExpressionPath) analyzeCallExpressionUsage(babelTypes, pruneContext, callExpressionPath, dictionaryKey, currentSourceFilePath, isSfcFile);
+		else recordFieldUsage(pruneContext, dictionaryKey, "all");
+		return;
+	}
 	if (callerConfig.translationFunction === "self") {
 		const firstArg = callArguments[0];
 		if (!firstArg) {
 			recordFieldUsage(pruneContext, dictionaryKey, "all");
 			return;
 		}
-		if (callerConfig.namespace.from === "path-first-segment") {
+		if (callerConfig.namespaceSources.some((source) => source.from === "path-first-segment")) {
 			let fullId;
 			const staticString = readStaticString(babelTypes, firstArg);
 			if (staticString !== void 0) fullId = staticString;
@@ -347,7 +438,7 @@ const analyzeNamespaceCallerUsage = (babelTypes, pruneContext, callArguments, ca
 			}
 			if (fullId !== void 0) {
 				const field = fullId.split(".")[1];
-				if (field !== void 0) recordFieldUsage(pruneContext, dictionaryKey, new Set([field]));
+				if (field !== void 0) recordFieldUsage(pruneContext, dictionaryKey, /* @__PURE__ */ new Set([field]));
 				else recordFieldUsage(pruneContext, dictionaryKey, "all");
 				return;
 			}
@@ -356,13 +447,13 @@ const analyzeNamespaceCallerUsage = (babelTypes, pruneContext, callArguments, ca
 		}
 		const segment = callerConfig.flatKey ? readStaticString(babelTypes, firstArg) : readStaticFirstSegment(babelTypes, firstArg);
 		if (segment !== void 0) {
-			recordFieldUsage(pruneContext, dictionaryKey, new Set([segment]));
+			recordFieldUsage(pruneContext, dictionaryKey, /* @__PURE__ */ new Set([segment]));
 			return;
 		}
 		if (babelTypes.isObjectExpression(firstArg)) {
 			const idValue = readObjectProperty(babelTypes, firstArg, "id");
 			if (idValue !== void 0 && idValue !== "__default__") {
-				recordFieldUsage(pruneContext, dictionaryKey, new Set([callerConfig.flatKey ? idValue : firstPathSegment(idValue)]));
+				recordFieldUsage(pruneContext, dictionaryKey, /* @__PURE__ */ new Set([callerConfig.flatKey ? idValue : firstPathSegment(idValue)]));
 				return;
 			}
 		}
@@ -373,14 +464,14 @@ const analyzeNamespaceCallerUsage = (babelTypes, pruneContext, callArguments, ca
 		recordFieldUsage(pruneContext, dictionaryKey, "all");
 		return;
 	}
-	const explicitKeyPrefix = resolveCompatKeyPrefix(babelTypes, callArguments, callerConfig.keyPrefix);
+	const explicitKeyPrefix = resolveCompatKeyPrefix(babelTypes, callArguments, callerConfig.keyPrefixSources);
 	if (explicitKeyPrefix === void 0) {
 		recordFieldUsage(pruneContext, dictionaryKey, "all");
 		return;
 	}
 	const effectivePrefix = namespacePrefix ?? explicitKeyPrefix;
 	if (effectivePrefix !== null) {
-		recordFieldUsage(pruneContext, dictionaryKey, new Set([firstPathSegment(effectivePrefix)]));
+		recordFieldUsage(pruneContext, dictionaryKey, /* @__PURE__ */ new Set([firstPathSegment(effectivePrefix)]));
 		return;
 	}
 	let translationBinding = null;
@@ -442,9 +533,10 @@ const makeUsageAnalyzerBabelPlugin = (pruneContext, options) => ({ types: babelT
 			const isSfcFile = currentSourceFilePath.endsWith(".vue") || currentSourceFilePath.endsWith(".svelte") || currentSourceFilePath.endsWith(".astro");
 			const intlayerCallerLocalNameMap = /* @__PURE__ */ new Map();
 			const compatCallerLocalNameMap = /* @__PURE__ */ new Map();
-			const methodCompatCallers = compatCallers.filter((caller) => caller.matchAsMethod);
+			const fileImportSources = /* @__PURE__ */ new Set();
 			programPath.traverse({ ImportDeclaration: (importDeclarationPath) => {
 				const importSource = importDeclarationPath.node.source.value;
+				fileImportSources.add(importSource);
 				for (const importSpecifier of importDeclarationPath.node.specifiers) {
 					if (!babelTypes.isImportSpecifier(importSpecifier)) continue;
 					const importedName = babelTypes.isIdentifier(importSpecifier.imported) ? importSpecifier.imported.name : importSpecifier.imported.value;
@@ -456,6 +548,7 @@ const makeUsageAnalyzerBabelPlugin = (pruneContext, options) => ({ types: babelT
 					if (compatCaller) compatCallerLocalNameMap.set(importSpecifier.local.name, compatCaller);
 				}
 			} });
+			const methodCompatCallers = compatCallers.filter((caller) => caller.matchAsMethod && (!caller.requiresImport || caller.importSources.some((source) => fileImportSources.has(source))));
 			const hasNativeCallers = intlayerCallerLocalNameMap.size > 0;
 			const hasCompatCallers = compatCallerLocalNameMap.size > 0 || methodCompatCallers.length > 0;
 			if (!hasNativeCallers && !hasCompatCallers) return;
@@ -480,12 +573,12 @@ const makeUsageAnalyzerBabelPlugin = (pruneContext, options) => ({ types: babelT
 					}
 					const importedCompatCaller = compatCallerLocalNameMap.get(localCallerName);
 					if (importedCompatCaller && !isMethodCall) {
-						analyzeNamespaceCallerUsage(babelTypes, pruneContext, callExpressionPath.node.arguments, importedCompatCaller, isSfcFile, callExpressionPath);
+						analyzeNamespaceCallerUsage(babelTypes, pruneContext, callExpressionPath.node.arguments, importedCompatCaller, isSfcFile, currentSourceFilePath, callExpressionPath);
 						return;
 					}
 					if (isMethodCall) {
 						const methodCaller = methodCompatCallers.find((caller) => caller.callerName === localCallerName);
-						if (methodCaller) analyzeNamespaceCallerUsage(babelTypes, pruneContext, callExpressionPath.node.arguments, methodCaller, isSfcFile, callExpressionPath);
+						if (methodCaller) analyzeNamespaceCallerUsage(babelTypes, pruneContext, callExpressionPath.node.arguments, methodCaller, isSfcFile, currentSourceFilePath, callExpressionPath);
 					}
 				},
 				JSXOpeningElement: (jsxOpeningElementPath) => {
@@ -494,7 +587,13 @@ const makeUsageAnalyzerBabelPlugin = (pruneContext, options) => ({ types: babelT
 					const jsxCaller = compatCallerLocalNameMap.get(nameNode.name);
 					if (!jsxCaller?.jsxIdAttribute) return;
 					const idNode = readJsxAttributeString(babelTypes, jsxOpeningElementPath.node, jsxCaller.jsxIdAttribute);
-					analyzeNamespaceCallerUsage(babelTypes, pruneContext, idNode ? [idNode] : [], jsxCaller, isSfcFile);
+					let namespaceOverride;
+					if (jsxCaller.jsxNamespaceAttribute) {
+						const namespaceNode = readJsxAttributeString(babelTypes, jsxOpeningElementPath.node, jsxCaller.jsxNamespaceAttribute);
+						if (!namespaceNode) return;
+						namespaceOverride = namespaceNode.value;
+					}
+					analyzeNamespaceCallerUsage(babelTypes, pruneContext, idNode ? [idNode] : [], jsxCaller, isSfcFile, currentSourceFilePath, void 0, namespaceOverride);
 				}
 			});
 		} } }