@intlayer/babel 9.4.4 → 9.5.0

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

@@ -1,694 +1,62 @@
+import { CHAINABLE_RUNTIME_METHOD_NAMES, INTLAYER_CALLER_NAMES, NATIVE_CALLER_NAME_SET } from "./nativeCallers.mjs";
+import { createPruneContext, preserveNestedDictionaryFields } from "./pruneContext.mjs";
+import { readStaticString, unwrapAwait } from "./staticAstReaders.mjs";
+import { analyzeCallExpressionUsage } from "./analyzeContentUsage.mjs";
+import { createCompatUsageAnalyzer } from "./compat/usageAnalysis.mjs";
+
 //#region src/babel-plugin-intlayer-usage-analyzer.ts
-const createPruneContext = () => ({
-	dictionaryKeyToFieldUsageMap: /* @__PURE__ */ new Map(),
-	dictionariesWithEdgeCases: /* @__PURE__ */ new Set(),
-	hasUnparsableSourceFiles: false,
-	dictionaryKeysWithUntrackedBindings: /* @__PURE__ */ new Map(),
-	dictionaryKeyToFieldRenameMap: /* @__PURE__ */ new Map(),
-	dictionaryKeysWithOpaqueFields: /* @__PURE__ */ new Map(),
-	dictionariesSkippingFieldRename: /* @__PURE__ */ new Set(),
-	pendingFrameworkAnalysis: /* @__PURE__ */ new Map()
-});
 /**
-* Records `nest()` references in a prune context so nest targets stay
-* resolvable — and no larger than they need to be — after purge and minify.
-*
-* A nested node stores the ORIGINAL dot path of the field it reads
-* (`nest('common', 'period')` → `'period'`) and `getNesting` resolves it at
-* runtime against the compiled JSON. That drives three adjustments:
-*
-* - Nest targets never take part in field renaming, since the stored path
-*   would no longer match the renamed keys.
-* - A target already consumed by a call site keeps its analysed fields plus
-*   the nested ones, so neither consumer loses content.
-* - A target reached *only* through `nest()` is given a usage entry holding
-*   exactly the nested fields. Without one, the purge pass leaves the whole
-*   dictionary untouched; with one, it trims the dictionary down to what the
-*   nest references actually read. This matters most for `dynamic` / `fetch`
-*   dictionaries, whose full static snapshot would otherwise be pulled into
-*   the eager bundle just to satisfy a single nested field.
-*
-* Seeding is skipped when a source file failed to parse: that file could
-* reference the dictionary in a way the analysis never saw, which is the same
-* guard the purge pass applies to keys with no usage entry.
-*
-* @param pruneContext - Shared analysis state to update in place.
-* @param nestedDictionaryReferences - Nest-target key → referenced top-level
-*   fields, as returned by `getNestedDictionaryReferences`.
-*/
-const preserveNestedDictionaryFields = (pruneContext, nestedDictionaryReferences) => {
-	for (const [dictionaryKey, nestedFields] of nestedDictionaryReferences.entries()) {
-		pruneContext.dictionariesSkippingFieldRename.add(dictionaryKey);
-		const currentFieldUsage = pruneContext.dictionaryKeyToFieldUsageMap.get(dictionaryKey);
-		if (nestedFields === "all") {
-			pruneContext.dictionaryKeyToFieldUsageMap.set(dictionaryKey, "all");
-			continue;
-		}
-		if (!currentFieldUsage) {
-			if (pruneContext.hasUnparsableSourceFiles) continue;
-			pruneContext.dictionaryKeyToFieldUsageMap.set(dictionaryKey, new Set(nestedFields));
-			continue;
-		}
-		if (currentFieldUsage === "all") continue;
-		for (const nestedField of nestedFields) currentFieldUsage.add(nestedField);
-	}
-};
-/**
-* Methods the runtime attaches to a resolved content object rather than fields
-* declared in a `.content` file.
-*
-* `vanilla-intlayer`'s `useIntlayer` / `useDictionary` assign `onChange` onto
-* the content they return, so `useIntlayer('app').onChange(cb)` is a
-* subscription — not a read of a field named `onChange`. Without this list the
-* analyser records `onChange` as the only consumed field and the purge pass
-* strips every real field from the compiled dictionary.
-*
-* The analyser looks *through* these calls: the callback parameter is analysed
-* as a fresh content root, and the call result is analysed again because the
-* helpers return the content object for chaining.
-*/
-const CHAINABLE_RUNTIME_METHOD_NAMES = /* @__PURE__ */ new Set(["onChange"]);
-/** Canonical intlayer caller names that trigger usage analysis. */
-const INTLAYER_CALLER_NAMES = [
-	"useIntlayer",
-	"getIntlayer",
-	"getIntlayerAsync"
-];
-/**
-* Default registry of compat namespace callers.
-*
-* Intentionally empty — compat-specific caller configurations belong in their
-* respective adapter packages (e.g. `@intlayer/react-i18next/plugin`,
-* `@intlayer/vue-i18n/plugin`) and are injected into `makeUsageAnalyzerBabelPlugin`
-* via the `compatCallers` option.  Centralising them here would couple the
-* core `@intlayer/babel` package to every compat adapter, which violates the
-* design principle that compat logic lives in compat packages.
+* @deprecated Always empty. Compat callers are injected per build through
+* `options.compatCallers`; there is no default registry to fall back to.
 */
 const DEFAULT_COMPAT_CALLERS = [];
-/** Default namespace used by compat callers when no namespace argument is given. */
-const DEFAULT_COMPAT_NAMESPACE = "translation";
-/**
-* Climbs past an enclosing `await` expression so that
-* `const t = await getTranslations('ns')` — or `await getIntlayerAsync('key')`
-* — is resolved to its variable declarator the same way the synchronous form
-* is.
-*/
-const unwrapAwait = (babelTypes, path) => {
-	const parentPath = path.parentPath;
-	if (parentPath && babelTypes.isAwaitExpression(parentPath.node)) return parentPath;
-	return path;
-};
-/**
-* Records the usage of a specific dictionary key's fields into `pruneContext`.
-* Merges with any previously recorded usage for the same key.
-*/
-const recordFieldUsage = (pruneContext, dictionaryKey, fieldUsage) => {
-	const existingUsage = pruneContext.dictionaryKeyToFieldUsageMap.get(dictionaryKey);
-	if (existingUsage === "all") return;
-	if (fieldUsage === "all") {
-		pruneContext.dictionaryKeyToFieldUsageMap.set(dictionaryKey, "all");
-		return;
-	}
-	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')`
-* call expression is consumed, then records the field usage into `pruneContext`.
-*
-* Recognised patterns:
-*   const { fieldA, fieldB } = useIntlayer('key')  → records {fieldA, fieldB}
-*   useIntlayer('key').fieldA                       → records {fieldA}
-*   useIntlayer('key')['fieldA']                    → records {fieldA}
-*   const { ...rest } = useIntlayer('key')          → records 'all' (spread)
-*   const result = useIntlayer('key')               → records 'all' (untracked binding)
-*/
-const analyzeCallExpressionUsage = (babelTypes, pruneContext, callExpressionPath, dictionaryKey, currentSourceFilePath, isSfcFile) => {
-	/** Mark the dictionary key as having an untracked binding in this file. */
-	const markUntrackedBinding = () => {
-		const existingPaths = pruneContext.dictionaryKeysWithUntrackedBindings.get(dictionaryKey) ?? [];
-		if (!existingPaths.includes(currentSourceFilePath)) pruneContext.dictionaryKeysWithUntrackedBindings.set(dictionaryKey, [...existingPaths, currentSourceFilePath]);
-		recordFieldUsage(pruneContext, dictionaryKey, "all");
-	};
-	/** 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 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) => {
-		const existing = pruneContext.pendingFrameworkAnalysis.get(currentSourceFilePath) ?? [];
-		if (!existing.some((e) => e.variableName === variableName && e.dictionaryKey === dictionaryKey)) existing.push({
-			variableName,
-			dictionaryKey
-		});
-		pruneContext.pendingFrameworkAnalysis.set(currentSourceFilePath, existing);
-	};
-	/**
-	* 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).
-	*
-	* 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, fieldPath) => {
-		const parentNode = refPath.parent;
-		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(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 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 (!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;
-	};
-	/**
-	* Returns the call path when `memberExprPath` is a chainable runtime helper
-	* being invoked (`content.onChange(cb)`), otherwise `undefined`.
-	*
-	* See {@link CHAINABLE_RUNTIME_METHOD_NAMES}: a bare `content.onChange`
-	* reference that is never called is treated as an ordinary field access, so
-	* only the invoked form is looked through.
-	*/
-	const getChainedRuntimeCallPath = (memberExprPath, fieldName) => {
-		if (!CHAINABLE_RUNTIME_METHOD_NAMES.has(fieldName)) return void 0;
-		if (!memberExprPath) return void 0;
-		const callPath = memberExprPath.parentPath;
-		if (!callPath) return void 0;
-		if (!callPath.isCallExpression() && !callPath.isOptionalCallExpression()) return;
-		if (callPath.node.callee !== memberExprPath.node) return;
-		return callPath;
-	};
-	/**
-	* Analyses the callbacks handed to a chainable runtime helper.
-	*
-	* The callback receives the freshly-resolved content root, so its parameter
-	* is walked exactly like `const content = useIntlayer('key')` — either as a
-	* plain binding or as a destructuring pattern.
-	*/
-	const analyzeChainedCallbackArguments = (callPath) => {
-		const argumentPaths = callPath.get("arguments");
-		for (const argumentPath of argumentPaths) {
-			if (!argumentPath.isArrowFunctionExpression() && !argumentPath.isFunctionExpression()) continue;
-			const [firstParameterPath] = argumentPath.get("params");
-			if (!firstParameterPath) continue;
-			if (firstParameterPath.isIdentifier()) {
-				const parameterBinding = argumentPath.scope.getBinding(firstParameterPath.node.name);
-				if (!parameterBinding) {
-					markUntrackedBinding();
-					continue;
-				}
-				const accessedFieldNames = /* @__PURE__ */ new Set();
-				if (analyzeContentBindingReferences(parameterBinding, accessedFieldNames)) markUntrackedBinding();
-				else recordFieldUsage(pruneContext, dictionaryKey, accessedFieldNames);
-				continue;
-			}
-			if (firstParameterPath.isObjectPattern()) {
-				const accessedFieldNames = /* @__PURE__ */ new Set();
-				if (collectFieldsFromObjectPattern(firstParameterPath.node, argumentPath, accessedFieldNames)) recordFieldUsage(pruneContext, dictionaryKey, accessedFieldNames);
-				else recordFieldUsage(pruneContext, dictionaryKey, "all");
-				continue;
-			}
-			markUntrackedBinding();
-		}
-	};
-	/**
-	* Walks every reference of a local binding holding the content root,
-	* collecting the top-level fields it reads into `accessedTopLevelFieldNames`.
-	*
-	* @returns `true` when a reference escaped static tracking, meaning the whole
-	*   dictionary must be kept.
-	*/
-	const analyzeContentBindingReferences = (variableBinding, accessedTopLevelFieldNames) => {
-		for (const variableReferencePath of variableBinding.referencePaths) {
-			const referenceParentNode = variableReferencePath.parent;
-			if ((babelTypes.isMemberExpression(referenceParentNode) || babelTypes.isOptionalMemberExpression(referenceParentNode)) && referenceParentNode.object === variableReferencePath.node) {
-				const memberExpressionNode = referenceParentNode;
-				let fieldName;
-				if (!memberExpressionNode.computed && babelTypes.isIdentifier(memberExpressionNode.property)) fieldName = memberExpressionNode.property.name;
-				else if (memberExpressionNode.computed && babelTypes.isStringLiteral(memberExpressionNode.property)) fieldName = memberExpressionNode.property.value;
-				if (fieldName) {
-					const memberExprPath = variableReferencePath.parentPath;
-					const chainedCallPath = getChainedRuntimeCallPath(memberExprPath, fieldName);
-					if (chainedCallPath) {
-						analyzeChainedCallbackArguments(chainedCallPath);
-						analyzeContentRoot(chainedCallPath);
-						continue;
-					}
-					accessedTopLevelFieldNames.add(fieldName);
-					if (memberExprPath) analyzeOpaqueUsage(memberExprPath, [fieldName]);
-				} else return true;
-			} else if (babelTypes.isArrayExpression(referenceParentNode)) return true;
-			else if ((babelTypes.isCallExpression(referenceParentNode) || babelTypes.isOptionalCallExpression(referenceParentNode)) && referenceParentNode.callee === variableReferencePath.node) {
-				const callExprPath = variableReferencePath.parentPath;
-				const callParent = callExprPath?.parent;
-				if (callParent && (babelTypes.isMemberExpression(callParent) || babelTypes.isOptionalMemberExpression(callParent)) && callParent.object === callExprPath?.node) {
-					const memberExpr = callParent;
-					let fieldName;
-					if (!memberExpr.computed && babelTypes.isIdentifier(memberExpr.property)) fieldName = memberExpr.property.name;
-					else if (memberExpr.computed && babelTypes.isStringLiteral(memberExpr.property)) fieldName = memberExpr.property.value;
-					if (fieldName) {
-						const memberExprPath = callExprPath?.parentPath;
-						const chainedCallPath = getChainedRuntimeCallPath(memberExprPath, fieldName);
-						if (chainedCallPath) {
-							analyzeChainedCallbackArguments(chainedCallPath);
-							analyzeContentRoot(chainedCallPath);
-							continue;
-						}
-						accessedTopLevelFieldNames.add(fieldName);
-						if (memberExprPath) analyzeOpaqueUsage(memberExprPath, [fieldName]);
-					} else return true;
-				} else if (callParent && babelTypes.isVariableDeclarator(callParent) && babelTypes.isObjectPattern(callParent.id) && callExprPath && collectFieldsFromObjectPattern(callParent.id, callExprPath, accessedTopLevelFieldNames)) {} else return true;
-			} else return true;
-		}
-		return false;
-	};
-	/**
-	* Analyses how the content root referenced by `rootPath` is consumed.
-	*
-	* `rootPath` is the `useIntlayer('key')` call itself, or any expression that
-	* evaluates back to the same content object — currently the result of a
-	* chainable runtime helper such as `.onChange(…)`.
-	*/
-	const analyzeContentRoot = (rootPath) => {
-		const parentNode = rootPath.parent;
-		if (babelTypes.isVariableDeclarator(parentNode) && babelTypes.isObjectPattern(parentNode.id)) {
-			const accessedFieldNames = /* @__PURE__ */ new Set();
-			if (collectFieldsFromObjectPattern(parentNode.id, rootPath, accessedFieldNames)) recordFieldUsage(pruneContext, dictionaryKey, accessedFieldNames);
-			else recordFieldUsage(pruneContext, dictionaryKey, "all");
-			return;
-		}
-		if ((babelTypes.isMemberExpression(parentNode) || babelTypes.isOptionalMemberExpression(parentNode)) && parentNode.object === rootPath.node) {
-			let fieldName;
-			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) {
-				const memberExprPath = rootPath.parentPath;
-				const chainedCallPath = getChainedRuntimeCallPath(memberExprPath, fieldName);
-				if (chainedCallPath) {
-					analyzeChainedCallbackArguments(chainedCallPath);
-					analyzeContentRoot(chainedCallPath);
-					return;
-				}
-				recordFieldUsage(pruneContext, dictionaryKey, /* @__PURE__ */ new Set([fieldName]));
-				if (memberExprPath) analyzeOpaqueUsage(memberExprPath, [fieldName]);
-			} else markUntrackedBinding();
-			return;
-		}
-		if (babelTypes.isVariableDeclarator(parentNode) && babelTypes.isIdentifier(parentNode.id)) {
-			const variableName = parentNode.id.name;
-			const variableBinding = rootPath.scope.getBinding(variableName);
-			if (!variableBinding) {
-				markUntrackedBinding();
-				return;
-			}
-			const accessedTopLevelFieldNames = /* @__PURE__ */ new Set();
-			if (analyzeContentBindingReferences(variableBinding, accessedTopLevelFieldNames)) markUntrackedBinding();
-			else if (isSfcFile) deferFrameworkAnalysis(variableName);
-			else if (variableBinding.referencePaths.length === 0) markUntrackedBinding();
-			else recordFieldUsage(pruneContext, dictionaryKey, accessedTopLevelFieldNames);
-			return;
-		}
-		if (babelTypes.isExpressionStatement(parentNode)) return;
-		markUntrackedBinding();
-	};
-	analyzeContentRoot(unwrapAwait(babelTypes, callExpressionPath));
-};
-/**
-* Reads a fully-static string from an AST node. Returns `undefined` for
-* dynamic values (identifiers, expressions, template literals with
-* interpolations, …).
-*/
-const readStaticString = (babelTypes, node) => {
-	if (!node) return void 0;
-	if (babelTypes.isStringLiteral(node)) return node.value;
-	if (babelTypes.isTemplateLiteral(node) && node.expressions.length === 0 && node.quasis.length === 1) return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw;
-};
-/** Returns the first dot-path segment of a key, e.g. `'a.b.c'` → `'a'`. */
-const firstPathSegment = (path) => path.split(".")[0] ?? path;
-/**
-* Reads the static first dot-path segment from a `t()` first-argument node.
-*
-*   t('counter.label')      → 'counter'
-*   t(`counter.${x}`)       → 'counter'   (static prefix before the first dot)
-*   t(`${x}.label`)         → undefined   (dynamic first segment)
-*   t(someVariable)         → undefined
-*/
-const readStaticFirstSegment = (babelTypes, node) => {
-	const staticString = readStaticString(babelTypes, node);
-	if (staticString !== void 0) return firstPathSegment(staticString);
-	if (babelTypes.isTemplateLiteral(node) && node.quasis.length > 0) {
-		const firstQuasi = node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw;
-		if (firstQuasi?.includes(".")) return firstPathSegment(firstQuasi);
-	}
-};
-/**
-* Reads a static string property from an object expression. Returns
-* `'__default__'` when the property is absent and `undefined` when present but
-* dynamic.
-*/
-const readObjectProperty = (babelTypes, objectExpression, propertyName) => {
-	for (const property of objectExpression.properties) {
-		if (!babelTypes.isObjectProperty(property)) continue;
-		if (!(babelTypes.isIdentifier(property.key) && property.key.name === propertyName || babelTypes.isStringLiteral(property.key) && property.key.value === propertyName)) continue;
-		return readStaticString(babelTypes, property.value) ?? void 0;
-	}
-	return "__default__";
-};
-/**
-* Reads a named JSX attribute as a static string and returns it wrapped in a
-* `StringLiteral` node so the result can be fed to the same namespace resolver
-* as a call argument. Handles both `id="home.title"` and `id={'home.title'}`.
-* Returns `undefined` when the attribute is absent or dynamic (`id={expr}`).
-*/
-const readJsxAttributeString = (babelTypes, openingElement, attributeName) => {
-	for (const attribute of openingElement.attributes) {
-		if (!babelTypes.isJSXAttribute(attribute)) continue;
-		if (!babelTypes.isJSXIdentifier(attribute.name) || attribute.name.name !== attributeName) continue;
-		const value = attribute.value;
-		if (babelTypes.isStringLiteral(value)) return value;
-		if (babelTypes.isJSXExpressionContainer(value)) {
-			const staticString = readStaticString(babelTypes, value.expression);
-			if (staticString !== void 0) return babelTypes.stringLiteral(staticString);
-		}
-		return;
-	}
-};
-/**
-* Resolves the namespace (dictionary key) for a compat caller call-site from
-* 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;
-	if (source.from === "path-first-segment") {
-		const firstArg = callArguments[0];
-		if (firstArg === void 0) return void 0;
-		const staticString = readStaticString(babelTypes, firstArg);
-		if (staticString !== void 0) return firstPathSegment(staticString);
-		if (babelTypes.isObjectExpression(firstArg)) {
-			const idValue = readObjectProperty(babelTypes, firstArg, "id");
-			if (idValue === "__default__") return "__default__";
-			if (idValue !== void 0) return firstPathSegment(idValue);
-			return;
-		}
-		return;
-	}
-	if (source.from === "argument") {
-		const argument = callArguments[source.index];
-		if (argument === void 0) return "__default__";
-		const staticString = readStaticString(babelTypes, argument);
-		if (staticString !== void 0) return staticString;
-		if (babelTypes.isObjectExpression(argument)) return readObjectProperty(babelTypes, argument, "namespace");
-		return;
-	}
-	const optionsArgument = callArguments[source.argumentIndex];
-	if (optionsArgument === void 0) return "__default__";
-	if (!babelTypes.isObjectExpression(optionsArgument)) return void 0;
-	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, sources) => {
-	if (!sources || sources.length === 0) return null;
-	const resolved = resolveNamespaceFromSources(babelTypes, callArguments, sources);
-	if (resolved === "__default__") return null;
-	return resolved;
-};
-/**
-* Analyses how the translation function produced by a compat namespace caller
-* (`useTranslation`, `useTranslations`, `getTranslations`, `getFixedT`,
-* `useI18n`) is consumed, then records the accessed top-level dictionary fields
-* into `pruneContext`.
-*
-* Dictionaries consumed this way are always added to
-* `dictionariesSkippingFieldRename`: the field accesses are string-literal
-* dot-paths inside `t()` calls, which the field-rename plugin cannot rewrite,
-* 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, 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(".");
-	const dictionaryKey = namespaceSegments[0] ?? namespaceString;
-	const namespacePrefix = namespaceSegments.length > 1 ? namespaceSegments.slice(1).join(".") : null;
-	pruneContext.dictionariesSkippingFieldRename.add(dictionaryKey);
-	if (isSfcFile) {
-		recordFieldUsage(pruneContext, dictionaryKey, "all");
-		return;
-	}
-	if (callerConfig.translationFunction === "all") {
-		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.namespaceSources.some((source) => source.from === "path-first-segment")) {
-			let fullId;
-			const staticString = readStaticString(babelTypes, firstArg);
-			if (staticString !== void 0) fullId = staticString;
-			else if (babelTypes.isObjectExpression(firstArg)) {
-				const idValue = readObjectProperty(babelTypes, firstArg, "id");
-				if (idValue !== void 0 && idValue !== "__default__") fullId = idValue;
-			}
-			if (fullId !== void 0) {
-				const field = fullId.split(".")[1];
-				if (field !== void 0) recordFieldUsage(pruneContext, dictionaryKey, /* @__PURE__ */ new Set([field]));
-				else recordFieldUsage(pruneContext, dictionaryKey, "all");
-				return;
-			}
-			recordFieldUsage(pruneContext, dictionaryKey, "all");
-			return;
-		}
-		const segment = callerConfig.flatKey ? readStaticString(babelTypes, firstArg) : readStaticFirstSegment(babelTypes, firstArg);
-		if (segment !== void 0) {
-			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, /* @__PURE__ */ new Set([callerConfig.flatKey ? idValue : firstPathSegment(idValue)]));
-				return;
-			}
-		}
-		recordFieldUsage(pruneContext, dictionaryKey, "all");
-		return;
-	}
-	if (!callExpressionPath) {
-		recordFieldUsage(pruneContext, dictionaryKey, "all");
-		return;
-	}
-	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, /* @__PURE__ */ new Set([firstPathSegment(effectivePrefix)]));
-		return;
-	}
-	let translationBinding = null;
-	if (callerConfig.translationFunction === "destructured-t") {
-		const parentNode = callExpressionPath.parent;
-		if (babelTypes.isVariableDeclarator(parentNode) && babelTypes.isObjectPattern(parentNode.id)) {
-			for (const property of parentNode.id.properties) if (babelTypes.isObjectProperty(property) && babelTypes.isIdentifier(property.key) && property.key.name === "t" && babelTypes.isIdentifier(property.value)) translationBinding = callExpressionPath.scope.getBinding(property.value.name) ?? null;
-		}
-	} else {
-		const parentNode = unwrapAwait(babelTypes, callExpressionPath).parent;
-		if (babelTypes.isVariableDeclarator(parentNode) && babelTypes.isIdentifier(parentNode.id)) translationBinding = callExpressionPath.scope.getBinding(parentNode.id.name) ?? null;
-	}
-	if (!translationBinding) {
-		recordFieldUsage(pruneContext, dictionaryKey, "all");
-		return;
-	}
-	const accessedFields = /* @__PURE__ */ new Set();
-	let hasUntrackedUsage = false;
-	for (const referencePath of translationBinding.referencePaths) {
-		const parentNode = referencePath.parent;
-		if (!((babelTypes.isCallExpression(parentNode) || babelTypes.isOptionalCallExpression(parentNode)) && parentNode.callee === referencePath.node)) {
-			hasUntrackedUsage = true;
-			break;
-		}
-		const firstArgument = parentNode.arguments[0];
-		const segment = readStaticFirstSegment(babelTypes, firstArgument);
-		if (segment === void 0) {
-			hasUntrackedUsage = true;
-			break;
-		}
-		accessedFields.add(segment);
-	}
-	if (hasUntrackedUsage) {
-		recordFieldUsage(pruneContext, dictionaryKey, "all");
-		return;
-	}
-	if (accessedFields.size > 0) recordFieldUsage(pruneContext, dictionaryKey, accessedFields);
-};
 /**
 * Creates a Babel plugin that traverses source files and records which
-* top-level dictionary fields each `useIntlayer` / `getIntlayer` call-site —
-* and each configured compat namespace caller — accesses. Results are
-* accumulated into `pruneContext`.
+* top-level dictionary fields each `useIntlayer` / `getIntlayer` call-site
+* accesses. Results are accumulated into `pruneContext`.
+*
+* Compat-adapter callers (`useTranslation`, `useTranslations`, `formatMessage`,
+* …) are *not* known to this plugin. Each compat package's bundler plugin
+* injects its own descriptors through `options.compatCallers`, and the whole
+* compat analysis then runs behind {@link createCompatUsageAnalyzer}. With no
+* descriptors injected — the default — none of that code is reached, so a
+* plain intlayer build behaves exactly as if the adapters did not exist.
 *
 * This plugin is analysis-only: it does not transform the code (`code: false`
 * should be passed to `transformAsync` when using it).
 *
 * @param pruneContext - Shared mutable state written by this plugin.
-* @param options      - Optional overrides. `compatCallers` defaults to
-*                       {@link DEFAULT_COMPAT_CALLERS}; pass `[]` to disable
-*                       compat-adapter analysis entirely.
+* @param options      - Optional overrides. `compatCallers` defaults to an
+*                       empty registry, disabling compat-adapter analysis.
 */
 const makeUsageAnalyzerBabelPlugin = (pruneContext, options) => ({ types: babelTypes }) => {
-	const compatCallers = options?.compatCallers ?? DEFAULT_COMPAT_CALLERS;
+	const compatCallers = options?.compatCallers ?? [];
 	return {
 		name: "intlayer-usage-analyzer",
 		visitor: { Program: { exit: (programPath, state) => {
-			const currentSourceFilePath = state.file.opts.filename ?? "unknown file";
-			const isSfcFile = currentSourceFilePath.endsWith(".vue") || currentSourceFilePath.endsWith(".svelte") || currentSourceFilePath.endsWith(".astro");
-			const intlayerCallerLocalNameMap = /* @__PURE__ */ new Map();
-			const compatCallerLocalNameMap = /* @__PURE__ */ new Map();
-			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) {
+			const sourceFilePath = state.file.opts.filename ?? "unknown file";
+			const isSfcFile = sourceFilePath.endsWith(".vue") || sourceFilePath.endsWith(".svelte") || sourceFilePath.endsWith(".astro");
+			const compatAnalyzer = createCompatUsageAnalyzer(babelTypes, pruneContext, compatCallers, {
+				sourceFilePath,
+				isSfcFile
+			});
+			const nativeCallerLocalNames = /* @__PURE__ */ new Set();
+			for (const statement of programPath.node.body) {
+				if (!babelTypes.isImportDeclaration(statement)) continue;
+				const importSource = statement.source.value;
+				for (const importSpecifier of statement.specifiers) {
 					if (!babelTypes.isImportSpecifier(importSpecifier)) continue;
 					const importedName = babelTypes.isIdentifier(importSpecifier.imported) ? importSpecifier.imported.name : importSpecifier.imported.value;
-					if (INTLAYER_CALLER_NAMES.includes(importedName)) {
-						intlayerCallerLocalNameMap.set(importSpecifier.local.name, importedName);
+					const localName = importSpecifier.local.name;
+					if (NATIVE_CALLER_NAME_SET.has(importedName)) {
+						nativeCallerLocalNames.add(localName);
 						continue;
 					}
-					const compatCaller = compatCallers.find((caller) => caller.callerName === importedName && caller.importSources.includes(importSource));
-					if (compatCaller) compatCallerLocalNameMap.set(importSpecifier.local.name, compatCaller);
+					compatAnalyzer?.noteImport(importSource, importedName, localName);
 				}
-			} });
-			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;
+			}
+			const hasCompatCallers = compatAnalyzer?.hasMatchableCallers() ?? false;
+			if (nativeCallerLocalNames.size === 0 && !hasCompatCallers) return;
 			programPath.traverse({
 				CallExpression: (callExpressionPath) => {
 					const calleeNode = callExpressionPath.node.callee;
@@ -700,37 +68,18 @@ const makeUsageAnalyzerBabelPlugin = (pruneContext, options) => ({ types: babelT
 						isMethodCall = true;
 					}
 					if (!localCallerName) return;
-					if (intlayerCallerLocalNameMap.has(localCallerName)) {
+					if (nativeCallerLocalNames.has(localCallerName)) {
 						const callArguments = callExpressionPath.node.arguments;
 						if (callArguments.length === 0) return;
 						const dictionaryKey = readStaticString(babelTypes, callArguments[0]);
 						if (!dictionaryKey) return;
-						analyzeCallExpressionUsage(babelTypes, pruneContext, callExpressionPath, dictionaryKey, currentSourceFilePath, isSfcFile);
-						return;
-					}
-					const importedCompatCaller = compatCallerLocalNameMap.get(localCallerName);
-					if (importedCompatCaller && !isMethodCall) {
-						analyzeNamespaceCallerUsage(babelTypes, pruneContext, callExpressionPath.node.arguments, importedCompatCaller, isSfcFile, currentSourceFilePath, callExpressionPath);
+						analyzeCallExpressionUsage(babelTypes, pruneContext, callExpressionPath, dictionaryKey, sourceFilePath, isSfcFile);
 						return;
 					}
-					if (isMethodCall) {
-						const methodCaller = methodCompatCallers.find((caller) => caller.callerName === localCallerName);
-						if (methodCaller) analyzeNamespaceCallerUsage(babelTypes, pruneContext, callExpressionPath.node.arguments, methodCaller, isSfcFile, currentSourceFilePath, callExpressionPath);
-					}
+					compatAnalyzer?.analyzeCall(callExpressionPath, localCallerName, isMethodCall);
 				},
 				JSXOpeningElement: (jsxOpeningElementPath) => {
-					const nameNode = jsxOpeningElementPath.node.name;
-					if (!babelTypes.isJSXIdentifier(nameNode)) return;
-					const jsxCaller = compatCallerLocalNameMap.get(nameNode.name);
-					if (!jsxCaller?.jsxIdAttribute) return;
-					const idNode = readJsxAttributeString(babelTypes, jsxOpeningElementPath.node, jsxCaller.jsxIdAttribute);
-					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);
+					compatAnalyzer?.analyzeJsxElement(jsxOpeningElementPath);
 				}
 			});
 		} } }
@@ -738,5 +87,5 @@ const makeUsageAnalyzerBabelPlugin = (pruneContext, options) => ({ types: babelT
 };
 
 //#endregion
-export { CHAINABLE_RUNTIME_METHOD_NAMES, DEFAULT_COMPAT_CALLERS, INTLAYER_CALLER_NAMES, createPruneContext, makeUsageAnalyzerBabelPlugin, preserveNestedDictionaryFields, unwrapAwait };
+export { CHAINABLE_RUNTIME_METHOD_NAMES, DEFAULT_COMPAT_CALLERS, INTLAYER_CALLER_NAMES, NATIVE_CALLER_NAME_SET, createPruneContext, makeUsageAnalyzerBabelPlugin, preserveNestedDictionaryFields, unwrapAwait };
 //# sourceMappingURL=babel-plugin-intlayer-usage-analyzer.mjs.map