@intlayer/babel 9.4.3 → 9.5.0

package/dist/cjs/staticAstReaders.cjs

@@ -0,0 +1,140 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region src/staticAstReaders.ts
+/**
+* Static-value readers shared by every pass that has to decide, at build time,
+* which dictionary a call site reads.
+*
+* They were previously duplicated — with small behavioural drifts — between
+* `babel-plugin-intlayer-optimize` and `babel-plugin-intlayer-usage-analyzer`.
+* Both now read through this module so a call site the analyser can attribute
+* is exactly the one the optimizer can rewrite.
+*/
+/**
+* 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 message-id 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);
+	}
+};
+/** Whether an object-property key (identifier or string literal) reads as `name`. */
+const propertyKeyMatches = (babelTypes, property, name) => babelTypes.isIdentifier(property.key) && property.key.name === name || babelTypes.isStringLiteral(property.key) && property.key.value === name;
+/**
+* Returns the `ObjectProperty` named `propertyName`, or `undefined` when the
+* object has no such property. Callers that need to mutate the property in
+* place (rewriting or deleting it) use this rather than a value reader.
+*/
+const findObjectProperty = (babelTypes, objectExpression, propertyName) => {
+	for (const property of objectExpression.properties) {
+		if (!babelTypes.isObjectProperty(property)) continue;
+		if (propertyKeyMatches(babelTypes, property, propertyName)) return property;
+	}
+};
+/**
+* Marker returned by the reader helpers when the requested property or
+* argument is simply absent — distinct from present-but-dynamic, which the
+* callers must treat conservatively.
+*/
+const ABSENT_VALUE = "__default__";
+/**
+* Reads a static string property from an object expression. Returns
+* {@link ABSENT_VALUE} when the property is absent and `undefined` when
+* present but dynamic.
+*/
+const readObjectProperty = (babelTypes, objectExpression, propertyName) => {
+	const property = findObjectProperty(babelTypes, objectExpression, propertyName);
+	if (!property) return ABSENT_VALUE;
+	return readStaticString(babelTypes, property.value);
+};
+/**
+* Returns the value *node* of a named property, so callers can apply their own
+* reader to it (a full static string, or just its leading path segment).
+* Returns {@link ABSENT_VALUE} when the property is absent.
+*/
+const readObjectPropertyNode = (babelTypes, objectExpression, propertyName) => {
+	const property = findObjectProperty(babelTypes, objectExpression, propertyName);
+	if (!property) return ABSENT_VALUE;
+	return property.value;
+};
+/**
+* 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;
+	}
+};
+/**
+* Splits a compat namespace at the first `.` to separate the dictionary key
+* from an optional key prefix, mirroring the SWC plugin's `split_namespace`.
+*
+*   `'about'`         → `{ dictionaryKey: 'about', keyPrefix: '' }`
+*   `'about.counter'` → `{ dictionaryKey: 'about', keyPrefix: 'counter' }`
+*/
+const splitNamespace = (namespace) => {
+	const dotPosition = namespace.indexOf(".");
+	if (dotPosition === -1) return {
+		dictionaryKey: namespace,
+		keyPrefix: ""
+	};
+	return {
+		dictionaryKey: namespace.slice(0, dotPosition),
+		keyPrefix: namespace.slice(dotPosition + 1)
+	};
+};
+/**
+* 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;
+};
+
+//#endregion
+exports.ABSENT_VALUE = ABSENT_VALUE;
+exports.findObjectProperty = findObjectProperty;
+exports.firstPathSegment = firstPathSegment;
+exports.propertyKeyMatches = propertyKeyMatches;
+exports.readJsxAttributeString = readJsxAttributeString;
+exports.readObjectProperty = readObjectProperty;
+exports.readObjectPropertyNode = readObjectPropertyNode;
+exports.readStaticFirstSegment = readStaticFirstSegment;
+exports.readStaticString = readStaticString;
+exports.splitNamespace = splitNamespace;
+exports.unwrapAwait = unwrapAwait;
+//# sourceMappingURL=staticAstReaders.cjs.map

package/dist/cjs/staticAstReaders.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"staticAstReaders.cjs","names":[],"sources":["../../src/staticAstReaders.ts"],"sourcesContent":["import type { NodePath } from '@babel/core';\nimport type * as BabelTypes from '@babel/types';\n\n/**\n * Static-value readers shared by every pass that has to decide, at build time,\n * which dictionary a call site reads.\n *\n * They were previously duplicated — with small behavioural drifts — between\n * `babel-plugin-intlayer-optimize` and `babel-plugin-intlayer-usage-analyzer`.\n * Both now read through this module so a call site the analyser can attribute\n * is exactly the one the optimizer can rewrite.\n */\n\n/**\n * Reads a fully-static string from an AST node. Returns `undefined` for\n * dynamic values (identifiers, expressions, template literals with\n * interpolations, …).\n */\nexport const readStaticString = (\n  babelTypes: typeof BabelTypes,\n  node: BabelTypes.Node | null | undefined\n): string | undefined => {\n  if (!node) return undefined;\n  if (babelTypes.isStringLiteral(node)) return node.value;\n  if (\n    babelTypes.isTemplateLiteral(node) &&\n    node.expressions.length === 0 &&\n    node.quasis.length === 1\n  ) {\n    return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw;\n  }\n  return undefined;\n};\n\n/** Returns the first dot-path segment of a key, e.g. `'a.b.c'` → `'a'`. */\nexport const firstPathSegment = (path: string): string =>\n  path.split('.')[0] ?? path;\n\n/**\n * Reads the static first dot-path segment from a message-id node.\n *\n *   t('counter.label')      → 'counter'\n *   t(`counter.${x}`)       → 'counter'   (static prefix before the first dot)\n *   t(`${x}.label`)         → undefined   (dynamic first segment)\n *   t(someVariable)         → undefined\n */\nexport const readStaticFirstSegment = (\n  babelTypes: typeof BabelTypes,\n  node: BabelTypes.Node | null | undefined\n): string | undefined => {\n  const staticString = readStaticString(babelTypes, node);\n  if (staticString !== undefined) return firstPathSegment(staticString);\n\n  // Template literal whose first quasi already contains the dot delimiter, e.g.\n  // `counter.${index}` → the leading `counter` segment is statically known.\n  if (babelTypes.isTemplateLiteral(node) && node.quasis.length > 0) {\n    const firstQuasi =\n      node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw;\n    if (firstQuasi?.includes('.')) {\n      return firstPathSegment(firstQuasi);\n    }\n  }\n  return undefined;\n};\n\n/** Whether an object-property key (identifier or string literal) reads as `name`. */\nexport const propertyKeyMatches = (\n  babelTypes: typeof BabelTypes,\n  property: BabelTypes.ObjectProperty,\n  name: string\n): boolean =>\n  (babelTypes.isIdentifier(property.key) && property.key.name === name) ||\n  (babelTypes.isStringLiteral(property.key) && property.key.value === name);\n\n/**\n * Returns the `ObjectProperty` named `propertyName`, or `undefined` when the\n * object has no such property. Callers that need to mutate the property in\n * place (rewriting or deleting it) use this rather than a value reader.\n */\nexport const findObjectProperty = (\n  babelTypes: typeof BabelTypes,\n  objectExpression: BabelTypes.ObjectExpression,\n  propertyName: string\n): BabelTypes.ObjectProperty | undefined => {\n  for (const property of objectExpression.properties) {\n    if (!babelTypes.isObjectProperty(property)) continue;\n    if (propertyKeyMatches(babelTypes, property, propertyName)) return property;\n  }\n  return undefined;\n};\n\n/**\n * Marker returned by the reader helpers when the requested property or\n * argument is simply absent — distinct from present-but-dynamic, which the\n * callers must treat conservatively.\n */\nexport const ABSENT_VALUE = '__default__' as const;\n\n/** Either a statically-known value, {@link ABSENT_VALUE}, or `undefined` (dynamic). */\nexport type StaticOrAbsent<T> = T | typeof ABSENT_VALUE | undefined;\n\n/**\n * Reads a static string property from an object expression. Returns\n * {@link ABSENT_VALUE} when the property is absent and `undefined` when\n * present but dynamic.\n */\nexport const readObjectProperty = (\n  babelTypes: typeof BabelTypes,\n  objectExpression: BabelTypes.ObjectExpression,\n  propertyName: string\n): StaticOrAbsent<string> => {\n  const property = findObjectProperty(\n    babelTypes,\n    objectExpression,\n    propertyName\n  );\n  if (!property) return ABSENT_VALUE;\n  return readStaticString(babelTypes, property.value); // present but dynamic → undefined\n};\n\n/**\n * Returns the value *node* of a named property, so callers can apply their own\n * reader to it (a full static string, or just its leading path segment).\n * Returns {@link ABSENT_VALUE} when the property is absent.\n */\nexport const readObjectPropertyNode = (\n  babelTypes: typeof BabelTypes,\n  objectExpression: BabelTypes.ObjectExpression,\n  propertyName: string\n): StaticOrAbsent<BabelTypes.Node> => {\n  const property = findObjectProperty(\n    babelTypes,\n    objectExpression,\n    propertyName\n  );\n  if (!property) return ABSENT_VALUE;\n  return property.value;\n};\n\n/**\n * Reads a named JSX attribute as a static string and returns it wrapped in a\n * `StringLiteral` node so the result can be fed to the same namespace resolver\n * as a call argument. Handles both `id=\"home.title\"` and `id={'home.title'}`.\n * Returns `undefined` when the attribute is absent or dynamic (`id={expr}`).\n */\nexport const readJsxAttributeString = (\n  babelTypes: typeof BabelTypes,\n  openingElement: BabelTypes.JSXOpeningElement,\n  attributeName: string\n): BabelTypes.StringLiteral | undefined => {\n  for (const attribute of openingElement.attributes) {\n    if (!babelTypes.isJSXAttribute(attribute)) continue;\n    if (\n      !babelTypes.isJSXIdentifier(attribute.name) ||\n      attribute.name.name !== attributeName\n    ) {\n      continue;\n    }\n\n    const value = attribute.value;\n    // id=\"home.title\"\n    if (babelTypes.isStringLiteral(value)) return value;\n    // id={'home.title'} / id={`home.title`}\n    if (babelTypes.isJSXExpressionContainer(value)) {\n      const staticString = readStaticString(babelTypes, value.expression);\n      if (staticString !== undefined) {\n        return babelTypes.stringLiteral(staticString);\n      }\n    }\n    return undefined; // attribute present but dynamic\n  }\n  return undefined; // attribute absent\n};\n\n/**\n * Splits a compat namespace at the first `.` to separate the dictionary key\n * from an optional key prefix, mirroring the SWC plugin's `split_namespace`.\n *\n *   `'about'`         → `{ dictionaryKey: 'about', keyPrefix: '' }`\n *   `'about.counter'` → `{ dictionaryKey: 'about', keyPrefix: 'counter' }`\n */\nexport const splitNamespace = (\n  namespace: string\n): { dictionaryKey: string; keyPrefix: string } => {\n  const dotPosition = namespace.indexOf('.');\n  if (dotPosition === -1) return { dictionaryKey: namespace, keyPrefix: '' };\n  return {\n    dictionaryKey: namespace.slice(0, dotPosition),\n    keyPrefix: namespace.slice(dotPosition + 1),\n  };\n};\n\n/**\n * Climbs past an enclosing `await` expression so that\n * `const t = await getTranslations('ns')` — or `await getIntlayerAsync('key')`\n * — is resolved to its variable declarator the same way the synchronous form\n * is.\n */\nexport const unwrapAwait = (\n  babelTypes: typeof BabelTypes,\n  path: NodePath<BabelTypes.Node>\n): NodePath<BabelTypes.Node> => {\n  const parentPath = path.parentPath;\n  if (parentPath && babelTypes.isAwaitExpression(parentPath.node)) {\n    return parentPath;\n  }\n  return path;\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,MAAa,oBACX,YACA,SACuB;CACvB,IAAI,CAAC,MAAM,OAAO;CAClB,IAAI,WAAW,gBAAgB,IAAI,GAAG,OAAO,KAAK;CAClD,IACE,WAAW,kBAAkB,IAAI,KACjC,KAAK,YAAY,WAAW,KAC5B,KAAK,OAAO,WAAW,GAEvB,OAAO,KAAK,OAAO,EAAE,EAAE,MAAM,UAAU,KAAK,OAAO,EAAE,EAAE,MAAM;AAGjE;;AAGA,MAAa,oBAAoB,SAC/B,KAAK,MAAM,GAAG,CAAC,CAAC,MAAM;;;;;;;;;AAUxB,MAAa,0BACX,YACA,SACuB;CACvB,MAAM,eAAe,iBAAiB,YAAY,IAAI;CACtD,IAAI,iBAAiB,QAAW,OAAO,iBAAiB,YAAY;CAIpE,IAAI,WAAW,kBAAkB,IAAI,KAAK,KAAK,OAAO,SAAS,GAAG;EAChE,MAAM,aACJ,KAAK,OAAO,EAAE,EAAE,MAAM,UAAU,KAAK,OAAO,EAAE,EAAE,MAAM;EACxD,IAAI,YAAY,SAAS,GAAG,GAC1B,OAAO,iBAAiB,UAAU;CAEtC;AAEF;;AAGA,MAAa,sBACX,YACA,UACA,SAEC,WAAW,aAAa,SAAS,GAAG,KAAK,SAAS,IAAI,SAAS,QAC/D,WAAW,gBAAgB,SAAS,GAAG,KAAK,SAAS,IAAI,UAAU;;;;;;AAOtE,MAAa,sBACX,YACA,kBACA,iBAC0C;CAC1C,KAAK,MAAM,YAAY,iBAAiB,YAAY;EAClD,IAAI,CAAC,WAAW,iBAAiB,QAAQ,GAAG;EAC5C,IAAI,mBAAmB,YAAY,UAAU,YAAY,GAAG,OAAO;CACrE;AAEF;;;;;;AAOA,MAAa,eAAe;;;;;;AAU5B,MAAa,sBACX,YACA,kBACA,iBAC2B;CAC3B,MAAM,WAAW,mBACf,YACA,kBACA,YACF;CACA,IAAI,CAAC,UAAU,OAAO;CACtB,OAAO,iBAAiB,YAAY,SAAS,KAAK;AACpD;;;;;;AAOA,MAAa,0BACX,YACA,kBACA,iBACoC;CACpC,MAAM,WAAW,mBACf,YACA,kBACA,YACF;CACA,IAAI,CAAC,UAAU,OAAO;CACtB,OAAO,SAAS;AAClB;;;;;;;AAQA,MAAa,0BACX,YACA,gBACA,kBACyC;CACzC,KAAK,MAAM,aAAa,eAAe,YAAY;EACjD,IAAI,CAAC,WAAW,eAAe,SAAS,GAAG;EAC3C,IACE,CAAC,WAAW,gBAAgB,UAAU,IAAI,KAC1C,UAAU,KAAK,SAAS,eAExB;EAGF,MAAM,QAAQ,UAAU;EAExB,IAAI,WAAW,gBAAgB,KAAK,GAAG,OAAO;EAE9C,IAAI,WAAW,yBAAyB,KAAK,GAAG;GAC9C,MAAM,eAAe,iBAAiB,YAAY,MAAM,UAAU;GAClE,IAAI,iBAAiB,QACnB,OAAO,WAAW,cAAc,YAAY;EAEhD;EACA;CACF;AAEF;;;;;;;;AASA,MAAa,kBACX,cACiD;CACjD,MAAM,cAAc,UAAU,QAAQ,GAAG;CACzC,IAAI,gBAAgB,IAAI,OAAO;EAAE,eAAe;EAAW,WAAW;CAAG;CACzE,OAAO;EACL,eAAe,UAAU,MAAM,GAAG,WAAW;EAC7C,WAAW,UAAU,MAAM,cAAc,CAAC;CAC5C;AACF;;;;;;;AAQA,MAAa,eACX,YACA,SAC8B;CAC9B,MAAM,aAAa,KAAK;CACxB,IAAI,cAAc,WAAW,kBAAkB,WAAW,IAAI,GAC5D,OAAO;CAET,OAAO;AACT"}

package/dist/cjs/transformers.cjs

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_nativeCallers = require('./nativeCallers.cjs');
 const require_babel_plugin_intlayer_usage_analyzer = require('./babel-plugin-intlayer-usage-analyzer.cjs');
 const require_extractScriptBlocks = require('./extractScriptBlocks.cjs');
 const require_babel_plugin_intlayer_field_rename = require('./babel-plugin-intlayer-field-rename.cjs');
@@ -48,7 +49,7 @@ const BABEL_PARSER_OPTIONS = {
 * @returns A `RegExp` matching any of the native or provided caller names.
 */
 const buildUsageCheckRegex = (extraCallerNames) => {
-	const callerNames = [...require_babel_plugin_intlayer_usage_analyzer.INTLAYER_CALLER_NAMES, ...extraCallerNames ?? []];
+	const callerNames = [...require_nativeCallers.INTLAYER_CALLER_NAMES, ...extraCallerNames ?? []];
 	const uniqueNames = [...new Set(callerNames)];
 	return new RegExp(`\\b(${uniqueNames.join("|")})\\b`);
 };

package/dist/cjs/transformers.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"transformers.cjs","names":["INTLAYER_CALLER_NAMES","transformAsync","makeUsageAnalyzerBabelPlugin","extractScriptBlocks","makeFieldRenameBabelPlugin","injectScriptBlocks","intlayerOptimizeBabelPlugin"],"sources":["../../src/transformers.ts"],"sourcesContent":["import { transformAsync } from '@babel/core';\n// Typed from `@babel/parser` rather than `@babel/core`'s\n// `InputOptions['parserOpts']` (Babel 8's rename of `TransformOptions`): the\n// two describe the same shape, but naming `@babel/core` in an exported type\n// pulls its declaration file into every consumer's type-check, and that file\n// needs `@types/convert-source-map` to resolve.\nimport type { ParserOptions } from '@babel/parser';\nimport { makeFieldRenameBabelPlugin } from './babel-plugin-intlayer-field-rename';\nimport {\n  intlayerOptimizeBabelPlugin,\n  type OptimizePluginOptions,\n} from './babel-plugin-intlayer-optimize';\nimport {\n  type CompatCallerConfig,\n  INTLAYER_CALLER_NAMES,\n  makeUsageAnalyzerBabelPlugin,\n  type PruneContext,\n} from './babel-plugin-intlayer-usage-analyzer';\nimport { extractScriptBlocks, injectScriptBlocks } from './extractScriptBlocks';\n\n// ── Shared Babel parser configuration ─────────────────────────────────────────\n\n/**\n * Babel parser options covering the superset of syntaxes used across all\n * supported frameworks (React / Vue / Svelte / Angular / …).\n */\nexport const BABEL_PARSER_OPTIONS: ParserOptions = {\n  sourceType: 'module',\n  allowImportExportEverywhere: true,\n  plugins: [\n    'typescript',\n    'jsx',\n    'decorators-legacy',\n    'classProperties',\n    'objectRestSpread',\n    'asyncGenerators',\n    'functionBind',\n    'exportDefaultFrom',\n    'exportNamespaceFrom',\n    'dynamicImport',\n    'nullishCoalescingOperator',\n    'optionalChaining',\n  ],\n};\n\n/**\n * Builds a fast pre-check regex that matches files potentially containing\n * native intlayer calls and/or the given compat namespace caller names.\n *\n * The result is used to skip files that definitely contain none of the\n * relevant function names, avoiding unnecessary Babel parsing.\n *\n * The native names come from {@link INTLAYER_CALLER_NAMES} rather than being\n * spelled out here: a name missing from this regex silently opts every file\n * using it out of the optimize, purge and minify passes, leaving its calls to\n * resolve through the dictionary registry — empty in browser bundles.\n *\n * Compat caller names are NOT hardcoded here — they are provided at runtime by\n * the compat adapter packages that configure the usage-analysis pipeline.\n *\n * @param extraCallerNames - Additional caller function names to match\n *   (e.g. `['useTranslation', 'getFixedT']` from `@intlayer/react-i18next`).\n * @returns A `RegExp` matching any of the native or provided caller names.\n */\nexport const buildUsageCheckRegex = (extraCallerNames?: string[]): RegExp => {\n  const callerNames = [...INTLAYER_CALLER_NAMES, ...(extraCallerNames ?? [])];\n  const uniqueNames = [...new Set(callerNames)];\n  return new RegExp(`\\\\b(${uniqueNames.join('|')})\\\\b`);\n};\n\n/**\n * Fast pre-check: matches files that could contain native intlayer calls\n * (`useIntlayer` / `getIntlayer` / `getIntlayerAsync`). Used by the\n * optimize/transform pass, which only rewrites native calls.\n */\nexport const INTLAYER_USAGE_REGEX = buildUsageCheckRegex();\n\n/** Usage-check regex covering only the native callers (no compat callers). */\nconst NATIVE_USAGE_CHECK_REGEX = INTLAYER_USAGE_REGEX;\n\n/** Cache of usage-check regexes, keyed by the compat-caller array reference. */\nconst usageCheckRegexCache = new WeakMap<\n  readonly CompatCallerConfig[],\n  RegExp\n>();\n\n/**\n * Returns the usage-check regex for the given compat callers, memoised by the\n * array reference. Plugins pass the same options array for every analysed\n * file, so the regex is built once per build instead of once per file.\n */\nexport const getUsageCheckRegex = (\n  compatCallers?: readonly CompatCallerConfig[]\n): RegExp => {\n  if (!compatCallers || compatCallers.length === 0) {\n    return NATIVE_USAGE_CHECK_REGEX;\n  }\n\n  let usageCheckRegex = usageCheckRegexCache.get(compatCallers);\n  if (!usageCheckRegex) {\n    usageCheckRegex = buildUsageCheckRegex(\n      compatCallers.map((caller) => caller.callerName)\n    );\n    usageCheckRegexCache.set(compatCallers, usageCheckRegex);\n  }\n  return usageCheckRegex;\n};\n\n/**\n * Matches source files that are valid targets for usage analysis and Babel\n * transformation. Excludes sourcemap files, declaration files, and other\n * non-source extensions.\n */\nexport const SOURCE_FILE_REGEX = /\\.(tsx?|[mc]?jsx?|vue|svelte|astro)$/;\n\n// ── High-level transformer functions ──────────────────────────────────────────\n\n/**\n * Runs the usage-analysis Babel plugin on a single JS/TS code string.\n *\n * This is analysis-only: the transformed code output is discarded.\n * Throws if Babel cannot parse the content.\n */\nconst analyzeScriptContent = async (\n  scriptContent: string,\n  sourceFilePath: string,\n  pruneContext: PruneContext,\n  compatCallers?: CompatCallerConfig[]\n): Promise<void> => {\n  await transformAsync(scriptContent, {\n    filename: sourceFilePath,\n    plugins: [makeUsageAnalyzerBabelPlugin(pruneContext, { compatCallers })],\n    parserOpts: BABEL_PARSER_OPTIONS,\n    ast: false,\n    code: false, // analysis only – no output needed\n  });\n};\n\n/**\n * Runs the usage-analysis Babel plugin on a source file, accumulating\n * field-usage data into `pruneContext`.\n *\n * For Vue / Svelte SFC files, script blocks are extracted before analysis so\n * Babel does not attempt to parse the full SFC syntax (templates, styles, …).\n * For plain JS/TS files, the whole file content is analysed directly.\n *\n * This is analysis-only: the transformed code output is discarded.\n * Throws if Babel cannot parse the file (caller should handle and flag\n * `pruneContext.hasUnparsableSourceFiles`).\n */\nexport const analyzeFieldUsageInFile = async (\n  sourceFilePath: string,\n  code: string,\n  pruneContext: PruneContext,\n  compatCallers?: CompatCallerConfig[]\n): Promise<void> => {\n  const usageCheckRegex = getUsageCheckRegex(compatCallers);\n  const scriptBlocks = extractScriptBlocks(sourceFilePath, code);\n\n  // For SFC files (Vue / Svelte): scriptBlocks[0].contentStartOffset > 0\n  // means we extracted actual <script> tags from the file.\n  // For plain JS/TS: extractScriptBlocks returns the whole file as a single\n  // block with offset 0, so we fall through to the same path.\n  for (const block of scriptBlocks) {\n    if (!usageCheckRegex.test(block.content)) continue;\n    await analyzeScriptContent(\n      block.content,\n      sourceFilePath,\n      pruneContext,\n      compatCallers\n    );\n  }\n};\n\n/**\n * Applies field-renaming to a single JS/TS code string (not an SFC).\n *\n * Returns the renamed code string, or `null` if nothing changed or if\n * Babel failed to parse the input (caller should fall back to original code).\n */\nexport const renameFieldsInCode = async (\n  code: string,\n  sourceFilePath: string,\n  pruneContext: PruneContext\n): Promise<string | null> => {\n  try {\n    const result = await transformAsync(code, {\n      filename: sourceFilePath,\n      plugins: [makeFieldRenameBabelPlugin(pruneContext)],\n      parserOpts: BABEL_PARSER_OPTIONS,\n      ast: false,\n    });\n    return result?.code ?? null;\n  } catch {\n    return null; // parse failure – caller falls back to original code\n  }\n};\n\n/**\n * Applies field-renaming to a source file, correctly handling both plain\n * JS/TS files and SFC files (Vue / Svelte) by operating on each script block\n * individually and injecting the results back into the original source.\n *\n * Returns the renamed code string, or `null` if nothing changed.\n */\nexport const renameFieldsInSourceFile = async (\n  sourceFilePath: string,\n  code: string,\n  pruneContext: PruneContext\n): Promise<string | null> => {\n  if (pruneContext.dictionaryKeyToFieldRenameMap.size === 0) return null;\n  if (!INTLAYER_USAGE_REGEX.test(code)) return null;\n\n  const scriptBlocks = extractScriptBlocks(sourceFilePath, code);\n\n  const isSFC =\n    scriptBlocks.length > 0 &&\n    ((scriptBlocks[0]?.contentStartOffset ?? 0) > 0 || scriptBlocks.length > 1);\n\n  if (isSFC) {\n    // Raw SFC: rename each script block individually and inject back.\n    const modifications: Array<{\n      block: (typeof scriptBlocks)[number];\n      modifiedContent: string;\n    }> = [];\n\n    for (const block of scriptBlocks) {\n      if (!INTLAYER_USAGE_REGEX.test(block.content)) continue;\n\n      const renamedCode = await renameFieldsInCode(\n        block.content,\n        sourceFilePath,\n        pruneContext\n      );\n      if (renamedCode && renamedCode !== block.content) {\n        modifications.push({ block, modifiedContent: renamedCode });\n      }\n    }\n\n    if (modifications.length === 0) return null;\n    return injectScriptBlocks(code, modifications);\n  }\n\n  // Plain JS/TS or compiled SFC (no block delimiters) – rename the whole file.\n  return renameFieldsInCode(code, sourceFilePath, pruneContext);\n};\n\n/**\n * Runs the intlayer optimize Babel plugin on a source file, transforming\n * `useIntlayer('key')` / `getIntlayer('key')` calls into `useDictionary(_hash)`\n * / `getDictionary(_hash)` and injecting the corresponding dictionary imports.\n *\n * Returns `{ code, map }` on success, or `null` if the transformation produced\n * no output.\n */\nexport const optimizeSourceFile = async (\n  code: string,\n  sourceFilePath: string,\n  options: OptimizePluginOptions\n): Promise<{\n  code: string;\n  map: string | object | null | undefined;\n} | null> => {\n  const result = await transformAsync(code, {\n    filename: sourceFilePath,\n    plugins: [[intlayerOptimizeBabelPlugin, options]],\n    parserOpts: BABEL_PARSER_OPTIONS,\n  });\n\n  if (!result?.code) return null;\n\n  return { code: result.code, map: result.map };\n};\n"],"mappings":";;;;;;;;;;;;AA0BA,MAAa,uBAAsC;CACjD,YAAY;CACZ,6BAA6B;CAC7B,SAAS;EACP;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACF;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,wBAAwB,qBAAwC;CAC3E,MAAM,cAAc,CAAC,GAAGA,oEAAuB,GAAI,oBAAoB,CAAC,CAAE;CAC1E,MAAM,cAAc,CAAC,GAAG,IAAI,IAAI,WAAW,CAAC;CAC5C,OAAO,IAAI,OAAO,OAAO,YAAY,KAAK,GAAG,EAAE,KAAK;AACtD;;;;;;AAOA,MAAa,uBAAuB,qBAAqB;;AAGzD,MAAM,2BAA2B;;AAGjC,MAAM,uCAAuB,IAAI,QAG/B;;;;;;AAOF,MAAa,sBACX,kBACW;CACX,IAAI,CAAC,iBAAiB,cAAc,WAAW,GAC7C,OAAO;CAGT,IAAI,kBAAkB,qBAAqB,IAAI,aAAa;CAC5D,IAAI,CAAC,iBAAiB;EACpB,kBAAkB,qBAChB,cAAc,KAAK,WAAW,OAAO,UAAU,CACjD;EACA,qBAAqB,IAAI,eAAe,eAAe;CACzD;CACA,OAAO;AACT;;;;;;AAOA,MAAa,oBAAoB;;;;;;;AAUjC,MAAM,uBAAuB,OAC3B,eACA,gBACA,cACA,kBACkB;CAClB,UAAMC,4BAAe,eAAe;EAClC,UAAU;EACV,SAAS,CAACC,0EAA6B,cAAc,EAAE,cAAc,CAAC,CAAC;EACvE,YAAY;EACZ,KAAK;EACL,MAAM;CACR,CAAC;AACH;;;;;;;;;;;;;AAcA,MAAa,0BAA0B,OACrC,gBACA,MACA,cACA,kBACkB;CAClB,MAAM,kBAAkB,mBAAmB,aAAa;CACxD,MAAM,eAAeC,gDAAoB,gBAAgB,IAAI;CAM7D,KAAK,MAAM,SAAS,cAAc;EAChC,IAAI,CAAC,gBAAgB,KAAK,MAAM,OAAO,GAAG;EAC1C,MAAM,qBACJ,MAAM,SACN,gBACA,cACA,aACF;CACF;AACF;;;;;;;AAQA,MAAa,qBAAqB,OAChC,MACA,gBACA,iBAC2B;CAC3B,IAAI;EAOF,QAAO,UANcF,4BAAe,MAAM;GACxC,UAAU;GACV,SAAS,CAACG,sEAA2B,YAAY,CAAC;GAClD,YAAY;GACZ,KAAK;EACP,CAAC,EACY,EAAE,QAAQ;CACzB,QAAQ;EACN,OAAO;CACT;AACF;;;;;;;;AASA,MAAa,2BAA2B,OACtC,gBACA,MACA,iBAC2B;CAC3B,IAAI,aAAa,8BAA8B,SAAS,GAAG,OAAO;CAClE,IAAI,CAAC,qBAAqB,KAAK,IAAI,GAAG,OAAO;CAE7C,MAAM,eAAeD,gDAAoB,gBAAgB,IAAI;CAM7D,IAHE,aAAa,SAAS,OACpB,aAAa,EAAE,EAAE,sBAAsB,KAAK,KAAK,aAAa,SAAS,IAEhE;EAET,MAAM,gBAGD,CAAC;EAEN,KAAK,MAAM,SAAS,cAAc;GAChC,IAAI,CAAC,qBAAqB,KAAK,MAAM,OAAO,GAAG;GAE/C,MAAM,cAAc,MAAM,mBACxB,MAAM,SACN,gBACA,YACF;GACA,IAAI,eAAe,gBAAgB,MAAM,SACvC,cAAc,KAAK;IAAE;IAAO,iBAAiB;GAAY,CAAC;EAE9D;EAEA,IAAI,cAAc,WAAW,GAAG,OAAO;EACvC,OAAOE,+CAAmB,MAAM,aAAa;CAC/C;CAGA,OAAO,mBAAmB,MAAM,gBAAgB,YAAY;AAC9D;;;;;;;;;AAUA,MAAa,qBAAqB,OAChC,MACA,gBACA,YAIW;CACX,MAAM,SAAS,UAAMJ,4BAAe,MAAM;EACxC,UAAU;EACV,SAAS,CAAC,CAACK,oEAA6B,OAAO,CAAC;EAChD,YAAY;CACd,CAAC;CAED,IAAI,CAAC,QAAQ,MAAM,OAAO;CAE1B,OAAO;EAAE,MAAM,OAAO;EAAM,KAAK,OAAO;CAAI;AAC9C"}
+{"version":3,"file":"transformers.cjs","names":["INTLAYER_CALLER_NAMES","transformAsync","makeUsageAnalyzerBabelPlugin","extractScriptBlocks","makeFieldRenameBabelPlugin","injectScriptBlocks","intlayerOptimizeBabelPlugin"],"sources":["../../src/transformers.ts"],"sourcesContent":["import { transformAsync } from '@babel/core';\n// Typed from `@babel/parser` rather than `@babel/core`'s\n// `InputOptions['parserOpts']` (Babel 8's rename of `TransformOptions`): the\n// two describe the same shape, but naming `@babel/core` in an exported type\n// pulls its declaration file into every consumer's type-check, and that file\n// needs `@types/convert-source-map` to resolve.\nimport type { ParserOptions } from '@babel/parser';\nimport { makeFieldRenameBabelPlugin } from './babel-plugin-intlayer-field-rename';\nimport {\n  intlayerOptimizeBabelPlugin,\n  type OptimizePluginOptions,\n} from './babel-plugin-intlayer-optimize';\nimport {\n  type CompatCallerConfig,\n  INTLAYER_CALLER_NAMES,\n  makeUsageAnalyzerBabelPlugin,\n  type PruneContext,\n} from './babel-plugin-intlayer-usage-analyzer';\nimport { extractScriptBlocks, injectScriptBlocks } from './extractScriptBlocks';\n\n// ── Shared Babel parser configuration ─────────────────────────────────────────\n\n/**\n * Babel parser options covering the superset of syntaxes used across all\n * supported frameworks (React / Vue / Svelte / Angular / …).\n */\nexport const BABEL_PARSER_OPTIONS: ParserOptions = {\n  sourceType: 'module',\n  allowImportExportEverywhere: true,\n  plugins: [\n    'typescript',\n    'jsx',\n    'decorators-legacy',\n    'classProperties',\n    'objectRestSpread',\n    'asyncGenerators',\n    'functionBind',\n    'exportDefaultFrom',\n    'exportNamespaceFrom',\n    'dynamicImport',\n    'nullishCoalescingOperator',\n    'optionalChaining',\n  ],\n};\n\n/**\n * Builds a fast pre-check regex that matches files potentially containing\n * native intlayer calls and/or the given compat namespace caller names.\n *\n * The result is used to skip files that definitely contain none of the\n * relevant function names, avoiding unnecessary Babel parsing.\n *\n * The native names come from {@link INTLAYER_CALLER_NAMES} rather than being\n * spelled out here: a name missing from this regex silently opts every file\n * using it out of the optimize, purge and minify passes, leaving its calls to\n * resolve through the dictionary registry — empty in browser bundles.\n *\n * Compat caller names are NOT hardcoded here — they are provided at runtime by\n * the compat adapter packages that configure the usage-analysis pipeline.\n *\n * @param extraCallerNames - Additional caller function names to match\n *   (e.g. `['useTranslation', 'getFixedT']` from `@intlayer/react-i18next`).\n * @returns A `RegExp` matching any of the native or provided caller names.\n */\nexport const buildUsageCheckRegex = (extraCallerNames?: string[]): RegExp => {\n  const callerNames = [...INTLAYER_CALLER_NAMES, ...(extraCallerNames ?? [])];\n  const uniqueNames = [...new Set(callerNames)];\n  return new RegExp(`\\\\b(${uniqueNames.join('|')})\\\\b`);\n};\n\n/**\n * Fast pre-check: matches files that could contain native intlayer calls\n * (`useIntlayer` / `getIntlayer` / `getIntlayerAsync`). Used by the\n * optimize/transform pass, which only rewrites native calls.\n */\nexport const INTLAYER_USAGE_REGEX = buildUsageCheckRegex();\n\n/** Usage-check regex covering only the native callers (no compat callers). */\nconst NATIVE_USAGE_CHECK_REGEX = INTLAYER_USAGE_REGEX;\n\n/** Cache of usage-check regexes, keyed by the compat-caller array reference. */\nconst usageCheckRegexCache = new WeakMap<\n  readonly CompatCallerConfig[],\n  RegExp\n>();\n\n/**\n * Returns the usage-check regex for the given compat callers, memoised by the\n * array reference. Plugins pass the same options array for every analysed\n * file, so the regex is built once per build instead of once per file.\n */\nexport const getUsageCheckRegex = (\n  compatCallers?: readonly CompatCallerConfig[]\n): RegExp => {\n  if (!compatCallers || compatCallers.length === 0) {\n    return NATIVE_USAGE_CHECK_REGEX;\n  }\n\n  let usageCheckRegex = usageCheckRegexCache.get(compatCallers);\n  if (!usageCheckRegex) {\n    usageCheckRegex = buildUsageCheckRegex(\n      compatCallers.map((caller) => caller.callerName)\n    );\n    usageCheckRegexCache.set(compatCallers, usageCheckRegex);\n  }\n  return usageCheckRegex;\n};\n\n/**\n * Matches source files that are valid targets for usage analysis and Babel\n * transformation. Excludes sourcemap files, declaration files, and other\n * non-source extensions.\n */\nexport const SOURCE_FILE_REGEX = /\\.(tsx?|[mc]?jsx?|vue|svelte|astro)$/;\n\n// ── High-level transformer functions ──────────────────────────────────────────\n\n/**\n * Runs the usage-analysis Babel plugin on a single JS/TS code string.\n *\n * This is analysis-only: the transformed code output is discarded.\n * Throws if Babel cannot parse the content.\n */\nconst analyzeScriptContent = async (\n  scriptContent: string,\n  sourceFilePath: string,\n  pruneContext: PruneContext,\n  compatCallers?: CompatCallerConfig[]\n): Promise<void> => {\n  await transformAsync(scriptContent, {\n    filename: sourceFilePath,\n    plugins: [makeUsageAnalyzerBabelPlugin(pruneContext, { compatCallers })],\n    parserOpts: BABEL_PARSER_OPTIONS,\n    ast: false,\n    code: false, // analysis only – no output needed\n  });\n};\n\n/**\n * Runs the usage-analysis Babel plugin on a source file, accumulating\n * field-usage data into `pruneContext`.\n *\n * For Vue / Svelte SFC files, script blocks are extracted before analysis so\n * Babel does not attempt to parse the full SFC syntax (templates, styles, …).\n * For plain JS/TS files, the whole file content is analysed directly.\n *\n * This is analysis-only: the transformed code output is discarded.\n * Throws if Babel cannot parse the file (caller should handle and flag\n * `pruneContext.hasUnparsableSourceFiles`).\n */\nexport const analyzeFieldUsageInFile = async (\n  sourceFilePath: string,\n  code: string,\n  pruneContext: PruneContext,\n  compatCallers?: CompatCallerConfig[]\n): Promise<void> => {\n  const usageCheckRegex = getUsageCheckRegex(compatCallers);\n  const scriptBlocks = extractScriptBlocks(sourceFilePath, code);\n\n  // For SFC files (Vue / Svelte): scriptBlocks[0].contentStartOffset > 0\n  // means we extracted actual <script> tags from the file.\n  // For plain JS/TS: extractScriptBlocks returns the whole file as a single\n  // block with offset 0, so we fall through to the same path.\n  for (const block of scriptBlocks) {\n    if (!usageCheckRegex.test(block.content)) continue;\n    await analyzeScriptContent(\n      block.content,\n      sourceFilePath,\n      pruneContext,\n      compatCallers\n    );\n  }\n};\n\n/**\n * Applies field-renaming to a single JS/TS code string (not an SFC).\n *\n * Returns the renamed code string, or `null` if nothing changed or if\n * Babel failed to parse the input (caller should fall back to original code).\n */\nexport const renameFieldsInCode = async (\n  code: string,\n  sourceFilePath: string,\n  pruneContext: PruneContext\n): Promise<string | null> => {\n  try {\n    const result = await transformAsync(code, {\n      filename: sourceFilePath,\n      plugins: [makeFieldRenameBabelPlugin(pruneContext)],\n      parserOpts: BABEL_PARSER_OPTIONS,\n      ast: false,\n    });\n    return result?.code ?? null;\n  } catch {\n    return null; // parse failure – caller falls back to original code\n  }\n};\n\n/**\n * Applies field-renaming to a source file, correctly handling both plain\n * JS/TS files and SFC files (Vue / Svelte) by operating on each script block\n * individually and injecting the results back into the original source.\n *\n * Returns the renamed code string, or `null` if nothing changed.\n */\nexport const renameFieldsInSourceFile = async (\n  sourceFilePath: string,\n  code: string,\n  pruneContext: PruneContext\n): Promise<string | null> => {\n  if (pruneContext.dictionaryKeyToFieldRenameMap.size === 0) return null;\n  if (!INTLAYER_USAGE_REGEX.test(code)) return null;\n\n  const scriptBlocks = extractScriptBlocks(sourceFilePath, code);\n\n  const isSFC =\n    scriptBlocks.length > 0 &&\n    ((scriptBlocks[0]?.contentStartOffset ?? 0) > 0 || scriptBlocks.length > 1);\n\n  if (isSFC) {\n    // Raw SFC: rename each script block individually and inject back.\n    const modifications: Array<{\n      block: (typeof scriptBlocks)[number];\n      modifiedContent: string;\n    }> = [];\n\n    for (const block of scriptBlocks) {\n      if (!INTLAYER_USAGE_REGEX.test(block.content)) continue;\n\n      const renamedCode = await renameFieldsInCode(\n        block.content,\n        sourceFilePath,\n        pruneContext\n      );\n      if (renamedCode && renamedCode !== block.content) {\n        modifications.push({ block, modifiedContent: renamedCode });\n      }\n    }\n\n    if (modifications.length === 0) return null;\n    return injectScriptBlocks(code, modifications);\n  }\n\n  // Plain JS/TS or compiled SFC (no block delimiters) – rename the whole file.\n  return renameFieldsInCode(code, sourceFilePath, pruneContext);\n};\n\n/**\n * Runs the intlayer optimize Babel plugin on a source file, transforming\n * `useIntlayer('key')` / `getIntlayer('key')` calls into `useDictionary(_hash)`\n * / `getDictionary(_hash)` and injecting the corresponding dictionary imports.\n *\n * Returns `{ code, map }` on success, or `null` if the transformation produced\n * no output.\n */\nexport const optimizeSourceFile = async (\n  code: string,\n  sourceFilePath: string,\n  options: OptimizePluginOptions\n): Promise<{\n  code: string;\n  map: string | object | null | undefined;\n} | null> => {\n  const result = await transformAsync(code, {\n    filename: sourceFilePath,\n    plugins: [[intlayerOptimizeBabelPlugin, options]],\n    parserOpts: BABEL_PARSER_OPTIONS,\n  });\n\n  if (!result?.code) return null;\n\n  return { code: result.code, map: result.map };\n};\n"],"mappings":"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"}

package/dist/esm/analyzeContentUsage.mjs

@@ -0,0 +1,300 @@
+import { CHAINABLE_RUNTIME_METHOD_NAMES } from "./nativeCallers.mjs";
+import { recordFieldUsage } from "./pruneContext.mjs";
+import { unwrapAwait } from "./staticAstReaders.mjs";
+
+//#region src/analyzeContentUsage.ts
+/**
+* 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));
+};
+
+//#endregion
+export { analyzeCallExpressionUsage };
+//# sourceMappingURL=analyzeContentUsage.mjs.map

package/dist/esm/analyzeContentUsage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzeContentUsage.mjs","names":[],"sources":["../../src/analyzeContentUsage.ts"],"sourcesContent":["import type { NodePath } from '@babel/core';\nimport type * as BabelTypes from '@babel/types';\nimport { CHAINABLE_RUNTIME_METHOD_NAMES } from './nativeCallers';\nimport {\n  type OpaqueFieldOccurrence,\n  type PruneContext,\n  recordFieldUsage,\n} from './pruneContext';\nimport { unwrapAwait } from './staticAstReaders';\n\n/**\n * Analyses how the result of a single `useIntlayer('key')` / `getIntlayer('key')`\n * call expression is consumed, then records the field usage into `pruneContext`.\n *\n * Recognised patterns:\n *   const { fieldA, fieldB } = useIntlayer('key')  → records {fieldA, fieldB}\n *   useIntlayer('key').fieldA                       → records {fieldA}\n *   useIntlayer('key')['fieldA']                    → records {fieldA}\n *   const { ...rest } = useIntlayer('key')          → records 'all' (spread)\n *   const result = useIntlayer('key')               → records 'all' (untracked binding)\n */\nexport const analyzeCallExpressionUsage = (\n  babelTypes: typeof BabelTypes,\n  pruneContext: PruneContext,\n  callExpressionPath: NodePath<BabelTypes.CallExpression>,\n  dictionaryKey: string,\n  currentSourceFilePath: string,\n  isSfcFile: boolean\n): void => {\n  /** Mark the dictionary key as having an untracked binding in this file. */\n  const markUntrackedBinding = (): void => {\n    const existingPaths =\n      pruneContext.dictionaryKeysWithUntrackedBindings.get(dictionaryKey) ?? [];\n    if (!existingPaths.includes(currentSourceFilePath)) {\n      pruneContext.dictionaryKeysWithUntrackedBindings.set(dictionaryKey, [\n        ...existingPaths,\n        currentSourceFilePath,\n      ]);\n    }\n    recordFieldUsage(pruneContext, dictionaryKey, 'all');\n  };\n\n  /** Record that the content value at `fieldPath` is consumed opaquely. */\n  const markOpaqueField = (\n    fieldPath: string[],\n    line: number | undefined\n  ): void => {\n    const pathToOccurrence =\n      pruneContext.dictionaryKeysWithOpaqueFields.get(dictionaryKey) ??\n      new Map<string, OpaqueFieldOccurrence>();\n    const location =\n      line !== undefined\n        ? `${currentSourceFilePath}:${line}`\n        : currentSourceFilePath;\n    const joinedFieldPath = fieldPath.join('.');\n    const occurrence = pathToOccurrence.get(joinedFieldPath) ?? {\n      fieldPath: [...fieldPath],\n      locations: [],\n    };\n    if (!occurrence.locations.includes(location)) {\n      occurrence.locations.push(location);\n    }\n    pathToOccurrence.set(joinedFieldPath, occurrence);\n    pruneContext.dictionaryKeysWithOpaqueFields.set(\n      dictionaryKey,\n      pathToOccurrence\n    );\n  };\n\n  /** Register a plain variable binding in an SFC file for a second-pass analysis. */\n  const deferFrameworkAnalysis = (variableName: string): void => {\n    const existing =\n      pruneContext.pendingFrameworkAnalysis.get(currentSourceFilePath) ?? [];\n    if (\n      !existing.some(\n        (e) =>\n          e.variableName === variableName && e.dictionaryKey === dictionaryKey\n      )\n    ) {\n      existing.push({ variableName, dictionaryKey });\n    }\n    pruneContext.pendingFrameworkAnalysis.set(currentSourceFilePath, existing);\n  };\n\n  /**\n   * Analyses how the content value at `fieldPath` (currently referenced by\n   * `refPath`) is consumed, to detect opaque consumption (passing a dictionary\n   * value as-is to a prop or function argument).\n   *\n   * Member-access chains and destructuring are followed recursively with an\n   * extended field path, so the *terminal* consumption of a chain like\n   * `content.sections.hero` decides opacity — mirroring how far the\n   * source-code renamer can rewrite accesses. When the terminal consumption\n   * escapes static tracking, the deepest reached field path is marked opaque\n   * so the children of that value keep their original key names.\n   */\n  const analyzeOpaqueUsage = (\n    refPath: NodePath<BabelTypes.Node>,\n    fieldPath: string[]\n  ): void => {\n    const parentNode = refPath.parent;\n    const parentPath = refPath.parentPath;\n\n    // 1. Chained member access (e.g. field.sub or field?.sub): follow the\n    //    chain with an extended path and analyse the terminal consumption.\n    if (\n      parentPath &&\n      (babelTypes.isMemberExpression(parentNode) ||\n        babelTypes.isOptionalMemberExpression(parentNode)) &&\n      (parentNode as BabelTypes.MemberExpression).object === refPath.node\n    ) {\n      const memberNode = parentNode as BabelTypes.MemberExpression;\n\n      // Numeric index access ([0], [1], …) is transparent: the JSON renamers\n      // apply the same rename map to every array element.\n      if (\n        memberNode.computed &&\n        babelTypes.isNumericLiteral(memberNode.property)\n      ) {\n        analyzeOpaqueUsage(parentPath, fieldPath);\n        return;\n      }\n\n      if (\n        !memberNode.computed &&\n        babelTypes.isIdentifier(memberNode.property)\n      ) {\n        analyzeOpaqueUsage(parentPath, [\n          ...fieldPath,\n          memberNode.property.name,\n        ]);\n        return;\n      }\n\n      if (\n        memberNode.computed &&\n        babelTypes.isStringLiteral(memberNode.property)\n      ) {\n        analyzeOpaqueUsage(parentPath, [\n          ...fieldPath,\n          memberNode.property.value,\n        ]);\n        return;\n      }\n\n      // Dynamic computed access (field[expr]): the renamer cannot rewrite the\n      // key, so the children of the current path must keep their names.\n      markOpaqueField(fieldPath, refPath.node.loc?.start.line);\n      return;\n    }\n\n    // 2. Destructuring (e.g. const { sub } = field): follow each binding.\n    if (\n      babelTypes.isVariableDeclarator(parentNode) &&\n      babelTypes.isObjectPattern(parentNode.id) &&\n      parentNode.init === refPath.node\n    ) {\n      analyzeOpaqueDestructuring(parentNode.id, refPath, fieldPath);\n      return;\n    }\n\n    // 3. Ignored patterns (e.g. array literals [content])\n    if (babelTypes.isArrayExpression(parentNode)) {\n      return;\n    }\n\n    // 4. Opaque consumption (passed to prop, function, etc.)\n    markOpaqueField(fieldPath, refPath.node.loc?.start.line);\n  };\n\n  /**\n   * Analyses a destructuring pattern applied to the content value at\n   * `fieldPath`, recursively following each bound local variable's references\n   * via {@link analyzeOpaqueUsage}.\n   *\n   * Patterns the source-code renamer cannot rewrite (rest elements, dynamic\n   * computed keys, array patterns) mark the corresponding path opaque.\n   */\n  const analyzeOpaqueDestructuring = (\n    objectPattern: BabelTypes.ObjectPattern,\n    scopePath: NodePath<BabelTypes.Node>,\n    fieldPath: string[]\n  ): void => {\n    for (const property of objectPattern.properties) {\n      // A rest element re-exposes the remaining fields under their original\n      // names — nothing at this level may be renamed.\n      if (babelTypes.isRestElement(property)) {\n        markOpaqueField(fieldPath, property.loc?.start.line);\n        continue;\n      }\n      if (!babelTypes.isObjectProperty(property)) continue;\n\n      // Dynamic computed keys ({ [expr]: x }) cannot be renamed.\n      if (property.computed && !babelTypes.isStringLiteral(property.key)) {\n        markOpaqueField(fieldPath, property.loc?.start.line);\n        continue;\n      }\n\n      const keyName = babelTypes.isIdentifier(property.key)\n        ? property.key.name\n        : babelTypes.isStringLiteral(property.key)\n          ? property.key.value\n          : null;\n      if (!keyName) continue;\n\n      const childFieldPath = [...fieldPath, keyName];\n\n      // A default value ({ field = fallback }) wraps the binding target.\n      const bindingTarget = babelTypes.isAssignmentPattern(property.value)\n        ? property.value.left\n        : property.value;\n\n      if (babelTypes.isObjectPattern(bindingTarget)) {\n        analyzeOpaqueDestructuring(bindingTarget, scopePath, childFieldPath);\n        continue;\n      }\n\n      if (babelTypes.isIdentifier(bindingTarget)) {\n        const localVarBinding = scopePath.scope.getBinding(bindingTarget.name);\n        if (!localVarBinding) continue;\n        for (const referencePath of localVarBinding.referencePaths) {\n          analyzeOpaqueUsage(referencePath, childFieldPath);\n        }\n        continue;\n      }\n\n      // Array patterns and other targets escape the rename walk.\n      markOpaqueField(childFieldPath, property.loc?.start.line);\n    }\n  };\n\n  /**\n   * Helper to collect field names from an ObjectPattern (destructuring).\n   * Returns true if successful, false when the accessed fields cannot be\n   * determined statically (rest element or dynamic computed key → 'all').\n   */\n  const collectFieldsFromObjectPattern = (\n    pattern: BabelTypes.ObjectPattern,\n    initPath: NodePath<BabelTypes.Node>,\n    targetSet: Set<string>\n  ): boolean => {\n    if (pattern.properties.some((prop) => babelTypes.isRestElement(prop))) {\n      return false;\n    }\n\n    for (const property of pattern.properties) {\n      if (!babelTypes.isObjectProperty(property)) continue;\n\n      // Dynamic computed keys ({ [expr]: x }) cannot be attributed to a\n      // specific field — the whole dictionary must be kept.\n      if (property.computed && !babelTypes.isStringLiteral(property.key)) {\n        return false;\n      }\n\n      let fieldName: string | undefined;\n\n      if (!property.computed && babelTypes.isIdentifier(property.key)) {\n        fieldName = property.key.name;\n      } else if (babelTypes.isStringLiteral(property.key)) {\n        fieldName = property.key.value;\n      }\n\n      if (!fieldName) continue;\n\n      targetSet.add(fieldName);\n\n      // A default value ({ field = fallback }) wraps the binding target.\n      const bindingTarget = babelTypes.isAssignmentPattern(property.value)\n        ? property.value.left\n        : property.value;\n\n      if (babelTypes.isIdentifier(bindingTarget)) {\n        const variableBinding = initPath.scope.getBinding(bindingTarget.name);\n        if (variableBinding) {\n          for (const refPath of variableBinding.referencePaths) {\n            analyzeOpaqueUsage(refPath, [fieldName]);\n          }\n        }\n      } else if (babelTypes.isObjectPattern(bindingTarget)) {\n        // Nested pattern: const { fieldA: { nested } } = … — follow each\n        // nested binding so deeper opaque consumption is detected.\n        analyzeOpaqueDestructuring(bindingTarget, initPath, [fieldName]);\n      } else {\n        // Array patterns and other targets escape the rename walk.\n        markOpaqueField([fieldName], property.loc?.start.line);\n      }\n    }\n    return true;\n  };\n\n  /**\n   * Returns the call path when `memberExprPath` is a chainable runtime helper\n   * being invoked (`content.onChange(cb)`), otherwise `undefined`.\n   *\n   * See {@link CHAINABLE_RUNTIME_METHOD_NAMES}: a bare `content.onChange`\n   * reference that is never called is treated as an ordinary field access, so\n   * only the invoked form is looked through.\n   */\n  const getChainedRuntimeCallPath = (\n    memberExprPath: NodePath<BabelTypes.Node> | null | undefined,\n    fieldName: string\n  ): NodePath<BabelTypes.Node> | undefined => {\n    if (!CHAINABLE_RUNTIME_METHOD_NAMES.has(fieldName)) return undefined;\n    if (!memberExprPath) return undefined;\n\n    const callPath = memberExprPath.parentPath;\n    if (!callPath) return undefined;\n    if (!callPath.isCallExpression() && !callPath.isOptionalCallExpression()) {\n      return undefined;\n    }\n    if (\n      (callPath.node as BabelTypes.CallExpression).callee !==\n      memberExprPath.node\n    ) {\n      return undefined;\n    }\n\n    return callPath;\n  };\n\n  /**\n   * Analyses the callbacks handed to a chainable runtime helper.\n   *\n   * The callback receives the freshly-resolved content root, so its parameter\n   * is walked exactly like `const content = useIntlayer('key')` — either as a\n   * plain binding or as a destructuring pattern.\n   */\n  const analyzeChainedCallbackArguments = (\n    callPath: NodePath<BabelTypes.Node>\n  ): void => {\n    const argumentPaths = callPath.get(\n      'arguments'\n    ) as NodePath<BabelTypes.Node>[];\n\n    for (const argumentPath of argumentPaths) {\n      if (\n        !argumentPath.isArrowFunctionExpression() &&\n        !argumentPath.isFunctionExpression()\n      ) {\n        continue; // not a callback (e.g. an options object) – nothing to read\n      }\n\n      const [firstParameterPath] = argumentPath.get(\n        'params'\n      ) as NodePath<BabelTypes.Node>[];\n      if (!firstParameterPath) continue; // callback ignores the content\n\n      // (content) => … — walk the parameter's references.\n      if (firstParameterPath.isIdentifier()) {\n        const parameterBinding = argumentPath.scope.getBinding(\n          firstParameterPath.node.name\n        );\n        if (!parameterBinding) {\n          markUntrackedBinding();\n          continue;\n        }\n\n        const accessedFieldNames = new Set<string>();\n        if (\n          analyzeContentBindingReferences(parameterBinding, accessedFieldNames)\n        ) {\n          markUntrackedBinding();\n        } else {\n          recordFieldUsage(pruneContext, dictionaryKey, accessedFieldNames);\n        }\n        continue;\n      }\n\n      // ({ title }) => … — destructured directly in the parameter list.\n      if (firstParameterPath.isObjectPattern()) {\n        const accessedFieldNames = new Set<string>();\n        if (\n          collectFieldsFromObjectPattern(\n            firstParameterPath.node,\n            argumentPath,\n            accessedFieldNames\n          )\n        ) {\n          recordFieldUsage(pruneContext, dictionaryKey, accessedFieldNames);\n        } else {\n          recordFieldUsage(pruneContext, dictionaryKey, 'all');\n        }\n        continue;\n      }\n\n      markUntrackedBinding();\n    }\n  };\n\n  /**\n   * Walks every reference of a local binding holding the content root,\n   * collecting the top-level fields it reads into `accessedTopLevelFieldNames`.\n   *\n   * @returns `true` when a reference escaped static tracking, meaning the whole\n   *   dictionary must be kept.\n   */\n  const analyzeContentBindingReferences = (\n    variableBinding: { referencePaths: NodePath<BabelTypes.Node>[] },\n    accessedTopLevelFieldNames: Set<string>\n  ): boolean => {\n    for (const variableReferencePath of variableBinding.referencePaths) {\n      const referenceParentNode = variableReferencePath.parent;\n\n      if (\n        (babelTypes.isMemberExpression(referenceParentNode) ||\n          babelTypes.isOptionalMemberExpression(referenceParentNode)) &&\n        (referenceParentNode as BabelTypes.MemberExpression).object ===\n          variableReferencePath.node\n      ) {\n        const memberExpressionNode =\n          referenceParentNode as BabelTypes.MemberExpression;\n        let fieldName: string | undefined;\n\n        if (\n          !memberExpressionNode.computed &&\n          babelTypes.isIdentifier(memberExpressionNode.property)\n        ) {\n          fieldName = memberExpressionNode.property.name;\n        } else if (\n          memberExpressionNode.computed &&\n          babelTypes.isStringLiteral(memberExpressionNode.property)\n        ) {\n          fieldName = memberExpressionNode.property.value;\n        }\n\n        if (fieldName) {\n          const memberExprPath = variableReferencePath.parentPath;\n\n          // content.onChange(cb) — a runtime subscription, not a field read.\n          const chainedCallPath = getChainedRuntimeCallPath(\n            memberExprPath,\n            fieldName\n          );\n          if (chainedCallPath) {\n            analyzeChainedCallbackArguments(chainedCallPath);\n            analyzeContentRoot(chainedCallPath);\n            continue;\n          }\n\n          accessedTopLevelFieldNames.add(fieldName);\n\n          // Check usage of the field to look for opaque consumption\n          if (memberExprPath) {\n            analyzeOpaqueUsage(memberExprPath, [fieldName]);\n          }\n        } else {\n          // Dynamic computed access – cannot resolve statically\n          return true;\n        }\n      } else if (babelTypes.isArrayExpression(referenceParentNode)) {\n        // The binding's value escapes into an array literal\n        // (e.g. `[appleWatch, airpods].map((entry) => entry.name)`). Its fields\n        // are then accessed through iteration that Babel cannot follow back to\n        // this dictionary, so we cannot know which fields are used. This is the\n        // canonical meta-record / collection access pattern — conservatively\n        // keep every field rather than pruning the content to nothing.\n        return true;\n      } else if (\n        // Solid / Angular: content() signal accessor → content().field\n        (babelTypes.isCallExpression(referenceParentNode) ||\n          babelTypes.isOptionalCallExpression(referenceParentNode)) &&\n        (referenceParentNode as BabelTypes.CallExpression).callee ===\n          variableReferencePath.node\n      ) {\n        const callExprPath = variableReferencePath.parentPath;\n        const callParent = callExprPath?.parent;\n\n        if (\n          callParent &&\n          (babelTypes.isMemberExpression(callParent) ||\n            babelTypes.isOptionalMemberExpression(callParent)) &&\n          (callParent as BabelTypes.MemberExpression).object ===\n            callExprPath?.node\n        ) {\n          // content().field\n          const memberExpr = callParent as BabelTypes.MemberExpression;\n          let fieldName: string | undefined;\n\n          if (\n            !memberExpr.computed &&\n            babelTypes.isIdentifier(memberExpr.property)\n          ) {\n            fieldName = memberExpr.property.name;\n          } else if (\n            memberExpr.computed &&\n            babelTypes.isStringLiteral(memberExpr.property)\n          ) {\n            fieldName = memberExpr.property.value;\n          }\n\n          if (fieldName) {\n            const memberExprPath = callExprPath?.parentPath;\n\n            // content().onChange(cb) — a runtime subscription, not a field.\n            const chainedCallPath = getChainedRuntimeCallPath(\n              memberExprPath,\n              fieldName\n            );\n            if (chainedCallPath) {\n              analyzeChainedCallbackArguments(chainedCallPath);\n              analyzeContentRoot(chainedCallPath);\n              continue;\n            }\n\n            accessedTopLevelFieldNames.add(fieldName);\n            if (memberExprPath) analyzeOpaqueUsage(memberExprPath, [fieldName]);\n          } else {\n            // content()[dynamicKey] – cannot resolve statically\n            return true;\n          }\n        } else if (\n          callParent &&\n          babelTypes.isVariableDeclarator(callParent) &&\n          babelTypes.isObjectPattern(callParent.id) &&\n          callExprPath &&\n          collectFieldsFromObjectPattern(\n            callParent.id,\n            callExprPath,\n            accessedTopLevelFieldNames\n          )\n        ) {\n          // const { title } = content()\n          // fields already added to accessedTopLevelFieldNames by collectFieldsFromObjectPattern\n        } else {\n          // content() with no field access or passed opaquely → cannot prune\n          return true;\n        }\n      } else {\n        // Variable used in a non-member-access context (spread, function arg, etc.)\n        return true;\n      }\n    }\n\n    return false;\n  };\n\n  /**\n   * Analyses how the content root referenced by `rootPath` is consumed.\n   *\n   * `rootPath` is the `useIntlayer('key')` call itself, or any expression that\n   * evaluates back to the same content object — currently the result of a\n   * chainable runtime helper such as `.onChange(…)`.\n   */\n  const analyzeContentRoot = (rootPath: NodePath<BabelTypes.Node>): void => {\n    const parentNode = rootPath.parent;\n\n    // ── Pattern 1: const { fieldA, fieldB } = useIntlayer('key') ────────────\n    if (\n      babelTypes.isVariableDeclarator(parentNode) &&\n      babelTypes.isObjectPattern(parentNode.id)\n    ) {\n      const accessedFieldNames = new Set<string>();\n      if (\n        collectFieldsFromObjectPattern(\n          parentNode.id,\n          rootPath,\n          accessedFieldNames\n        )\n      ) {\n        recordFieldUsage(pruneContext, dictionaryKey, accessedFieldNames);\n      } else {\n        recordFieldUsage(pruneContext, dictionaryKey, 'all');\n      }\n      return;\n    }\n\n    // ── Pattern 2: useIntlayer('key').fieldA / useIntlayer('key')?.fieldA ────\n    if (\n      (babelTypes.isMemberExpression(parentNode) ||\n        babelTypes.isOptionalMemberExpression(parentNode)) &&\n      (parentNode as BabelTypes.MemberExpression).object === rootPath.node\n    ) {\n      let fieldName: string | undefined;\n\n      if (\n        !parentNode.computed &&\n        babelTypes.isIdentifier(parentNode.property)\n      ) {\n        fieldName = parentNode.property.name;\n      } else if (\n        parentNode.computed &&\n        babelTypes.isStringLiteral(parentNode.property)\n      ) {\n        fieldName = parentNode.property.value;\n      }\n\n      if (fieldName) {\n        const memberExprPath = rootPath.parentPath;\n\n        // useIntlayer('key').onChange(cb) — a runtime subscription: read the\n        // fields out of the callback instead of recording `onChange` itself.\n        const chainedCallPath = getChainedRuntimeCallPath(\n          memberExprPath,\n          fieldName\n        );\n        if (chainedCallPath) {\n          analyzeChainedCallbackArguments(chainedCallPath);\n          analyzeContentRoot(chainedCallPath);\n          return;\n        }\n\n        recordFieldUsage(pruneContext, dictionaryKey, new Set([fieldName]));\n\n        // Check for opaque usage (e.g. passed directly to a prop)\n        if (memberExprPath) {\n          analyzeOpaqueUsage(memberExprPath, [fieldName]);\n        }\n      } else {\n        markUntrackedBinding();\n      }\n      return;\n    }\n\n    // ── Pattern 3: const content = useIntlayer('key') ───────────────────────\n    if (\n      babelTypes.isVariableDeclarator(parentNode) &&\n      babelTypes.isIdentifier(parentNode.id)\n    ) {\n      const variableName = parentNode.id.name;\n      const variableBinding = rootPath.scope.getBinding(variableName);\n\n      if (!variableBinding) {\n        markUntrackedBinding();\n        return;\n      }\n\n      const accessedTopLevelFieldNames = new Set<string>();\n      const hasUntrackedReferenceAccess = analyzeContentBindingReferences(\n        variableBinding,\n        accessedTopLevelFieldNames\n      );\n\n      if (hasUntrackedReferenceAccess) {\n        markUntrackedBinding();\n      } else if (isSfcFile) {\n        // Vue / Svelte SFC: defer to the framework-specific extractor because\n        // Babel scope analysis cannot see through `.value` or `$` indirection.\n        deferFrameworkAnalysis(variableName);\n      } else if (variableBinding.referencePaths.length === 0) {\n        // Non-SFC file with no visible references – keep all fields.\n        markUntrackedBinding();\n      } else {\n        recordFieldUsage(\n          pruneContext,\n          dictionaryKey,\n          accessedTopLevelFieldNames\n        );\n      }\n      return;\n    }\n\n    // ── Pattern 4: bare call – result is discarded ──────────────────────────\n    if (babelTypes.isExpressionStatement(parentNode)) {\n      return; // no usage to record\n    }\n\n    // ── Fallback: result passed as argument, used in ternary, etc. ──────────\n    markUntrackedBinding();\n  };\n\n  // `getIntlayerAsync('key')` is consumed through its `await`, so the content\n  // root is the await expression — reading the call's own parent would see\n  // only the `AwaitExpression` and give up on every field.\n  analyzeContentRoot(unwrapAwait(babelTypes, callExpressionPath));\n};\n"],"mappings":"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"}

package/dist/esm/babel-plugin-intlayer-field-rename.mjs

@@ -1,4 +1,5 @@
-import { CHAINABLE_RUNTIME_METHOD_NAMES, INTLAYER_CALLER_NAMES, unwrapAwait } from "./babel-plugin-intlayer-usage-analyzer.mjs";
+import { CHAINABLE_RUNTIME_METHOD_NAMES, NATIVE_CALLER_NAME_SET } from "./nativeCallers.mjs";
+import { unwrapAwait } from "./staticAstReaders.mjs";
 
 //#region src/babel-plugin-intlayer-field-rename.ts
 /**
@@ -310,7 +311,7 @@ const collectIntlayerCallerLocalNames = (babelTypes, programNode) => {
 		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);
+			if (NATIVE_CALLER_NAME_SET.has(importedName)) intlayerCallerLocalNameMap.set(importSpecifier.local.name, importedName);
 		}
 	}
 	return intlayerCallerLocalNameMap;