@intlayer/babel 9.4.4 → 9.5.0

package/dist/esm/staticAstReaders.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"staticAstReaders.mjs","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/esm/transformers.mjs

@@ -1,4 +1,5 @@
-import { INTLAYER_CALLER_NAMES, makeUsageAnalyzerBabelPlugin } from "./babel-plugin-intlayer-usage-analyzer.mjs";
+import { INTLAYER_CALLER_NAMES } from "./nativeCallers.mjs";
+import { makeUsageAnalyzerBabelPlugin } from "./babel-plugin-intlayer-usage-analyzer.mjs";
 import { extractScriptBlocks, injectScriptBlocks } from "./extractScriptBlocks.mjs";
 import { makeFieldRenameBabelPlugin } from "./babel-plugin-intlayer-field-rename.mjs";
 import { intlayerOptimizeBabelPlugin } from "./babel-plugin-intlayer-optimize.mjs";

package/dist/esm/transformers.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"transformers.mjs","names":[],"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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"}
+{"version":3,"file":"transformers.mjs","names":[],"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/types/analyzeContentUsage.d.ts

@@ -0,0 +1,18 @@
+import { PruneContext } from "./pruneContext.js";
+import { NodePath } from "@babel/core";
+import * as BabelTypes from "@babel/types";
+//#region src/analyzeContentUsage.d.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)
+ */
+export declare const analyzeCallExpressionUsage: (babelTypes: typeof BabelTypes, pruneContext: PruneContext, callExpressionPath: NodePath<BabelTypes.CallExpression>, dictionaryKey: string, currentSourceFilePath: string, isSfcFile: boolean) => void;
+//#endregion
+//# sourceMappingURL=analyzeContentUsage.d.ts.map

package/dist/types/analyzeContentUsage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzeContentUsage.d.ts","names":[],"sources":["../../src/analyzeContentUsage.ts"],"mappings":";;;;;;;;;;;;;;;qBAqBa,6BAA0B,mBAClB,YAAU,cACf,cAAY,oBACN,SAAS,WAAW,iBAAe,uBAClC,+BACQ"}

package/dist/types/babel-plugin-intlayer-field-rename.d.ts

@@ -1,4 +1,5 @@
-import { NestedRenameEntry, NestedRenameMap, PruneContext } from "./babel-plugin-intlayer-usage-analyzer.js";
+import { NestedRenameEntry, NestedRenameMap, PruneContext } from "./pruneContext.js";
+import "./babel-plugin-intlayer-usage-analyzer.js";
 import { NodePath, PluginObject } from "@babel/core";
 import * as BabelTypes from "@babel/types";
 //#region src/babel-plugin-intlayer-field-rename.d.ts

package/dist/types/babel-plugin-intlayer-field-rename.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-field-rename.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-field-rename.ts"],"mappings":";;;;;;;;qBA4Ba,yBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA0CtB,kCAA+B,0BAEzC;;;;;;;;;;;;qBA2EU,6BAA0B,WAC1B,iBAAe,iCAEzB;;;;;;;YAqBS;;EAEV;;EAEA,UAAU;;;YAIA,2BAA2B,eAErC;;;;;;;;;;;;;;qBAgCW,0BAAuB,cACpB,iBACb,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;qBA4aL,8BAA2B,mBACnB,YAAU,aAChB,SAAS,WAAW,UAAQ,cAC3B;;;;;;;;;;qBAsIH,6BAA0B,cACtB,oBAAY,OAAA;EACD,cAAc;MAAe"}
+{"version":3,"file":"babel-plugin-intlayer-field-rename.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-field-rename.ts"],"mappings":";;;;;;;;;qBA2Ba,yBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA0CtB,kCAA+B,0BAEzC;;;;;;;;;;;;qBA2EU,6BAA0B,WAC1B,iBAAe,iCAEzB;;;;;;;YAqBS;;EAEV;;EAEA,UAAU;;;YAIA,2BAA2B,eAErC;;;;;;;;;;;;;;qBAgCW,0BAAuB,cACpB,iBACb,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;qBA4aL,8BAA2B,mBACnB,YAAU,aAChB,SAAS,WAAW,UAAQ,cAC3B;;;;;;;;;;qBAsIH,6BAA0B,cACtB,oBAAY,OAAA;EACD,cAAc;MAAe"}

package/dist/types/babel-plugin-intlayer-optimize.d.ts

@@ -2,7 +2,6 @@ import { PluginObject, PluginPass } from "@babel/core";
 import * as BabelTypes from "@babel/types";
 import { CallerDescriptor } from "@intlayer/config/callers";
 //#region src/babel-plugin-intlayer-optimize.d.ts
-declare const CALLER_LIST: readonly ['useIntlayer', 'getIntlayer', 'getIntlayerAsync'];
 /**
  * Options for the optimization Babel plugin
  */
@@ -93,23 +92,18 @@ export type OptimizePluginOptions = {
    */
   compatCallers?: CallerDescriptor[];
 };
+/**
+ * Per-file plugin state.
+ *
+ * Only the two flags that have to survive from `pre` / `Program.enter` into
+ * `Program.exit` live here — the caller maps and the import registry are built
+ * and consumed inside `exit`, so they stay local to it.
+ */
 type State = PluginPass & {
   opts: OptimizePluginOptions;
-  /** map key → generated ident (per-file) for static imports */
-  _newStaticImports?: Map<string, BabelTypes.Identifier>;
-  /** map key → generated ident (per-file) for dynamic imports */
-  _newDynamicImports?: Map<string, BabelTypes.Identifier>;
-  /** whether the current file imported *any* intlayer package */
-  _hasValidImport?: boolean;
-  /** map from local identifier name to the imported intlayer func name ('useIntlayer' | 'getIntlayer') */
-  _callerMap?: Map<string, (typeof CALLER_LIST)[number]>;
-  /** map from local identifier name to the intlayer package it was imported from */
-  _callerPackageMap?: Map<string, string>;
-  /** map from local identifier name to the compat caller descriptor it was imported as */
-  _compatCallerMap?: Map<string, CallerDescriptor>;
-  /** whether the current file *is* the dictionaries entry file */
+  /** Whether the current file *is* a generated dictionaries entry file. */
   _isDictEntry?: boolean;
-  /** whether the current file is included in the filesList */
+  /** Whether the current file is covered by the `filesList` allowlist. */
   _isIncluded?: boolean;
 };
 /**

package/dist/types/babel-plugin-intlayer-optimize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-optimize.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-optimize.ts"],"mappings":";;;;cA8BM;;;;YAwDM;;;;EAIV;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;;;;;;;;;;;;EAeA;;;;EAIA;;;;EAIA,oBAAoB;;;;EAOpB;;;;EAIA;;;;;;;;;;;;;;EAcA,gBAAgB;;KAGb,QAAQ;EACX,MAAM;;EAEN,oBAAoB,YAAY,WAAW;;EAE3C,qBAAqB,YAAY,WAAW;;EAE5C;;EAEA,aAAa,oBAAoB;;EAEjC,oBAAoB;;EAEpB,mBAAmB,YAAY;;EAE/B;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+TW,8BAA2B;EACtC,cAAc;MACZ,aAAa"}
+{"version":3,"file":"babel-plugin-intlayer-optimize.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-optimize.ts"],"mappings":";;;;;;;YA8FY;;;;EAIV;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;EAIA;;;;;;;;;;;;;;;EAeA;;;;EAIA;;;;EAIA,oBAAoB;;;;EAOpB;;;;EAIA;;;;;;;;;;;;;;EAcA,gBAAgB;;;;;;;;;KAUb,QAAQ;EACX,MAAM;;EAEN;;EAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgTW,8BAA2B;EACtC,cAAc;MACZ,aAAa"}

package/dist/types/babel-plugin-intlayer-purge.d.ts

@@ -1,8 +1,9 @@
-import { CompatCallerConfig, PruneContext } from "./babel-plugin-intlayer-usage-analyzer.js";
+import { PruneContext } from "./pruneContext.js";
+import { CompatCallerConfig } from "./babel-plugin-intlayer-usage-analyzer.js";
 import { PluginObject } from "@babel/core";
 import * as BabelTypes from "@babel/types";
-import { IntlayerConfig } from "@intlayer/types/config";
 import { NestedFieldReferences } from "@intlayer/core/dictionaryManipulator";
+import { IntlayerConfig } from "@intlayer/types/config";
 //#region src/babel-plugin-intlayer-purge.d.ts
 /**
  * Pre-resolved options accepted by {@link intlayerPurgeBabelPlugin}.

package/dist/types/babel-plugin-intlayer-purge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-purge.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-purge.ts"],"mappings":";;;;;;;;;;;;;YA2CY;;;;;;EAMV;;;;;EAMA;;;;;;EAOA;;;;;;EAOA;;;;;;EAOA;;;;;EAMA;;;;;EAMA;;;;;;EAOA;;;;;;;;EASA,6BAA6B,YAAY;;;;;;EAOzC,8BAA8B;;;;;;;;;;;;EAgB9B,gBAAgB;;;;;;;EAQhB,YAAY,KAAK;;;;;;;;;;qBAwBN,wBAAqB,oBAAsB;;;;;;;;;;;;;;;;;;qBA0rB3C,2BAAwB,SAC1B,uBACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmIU,2BAAwB;EACnC,cAAc;MACZ"}
+{"version":3,"file":"babel-plugin-intlayer-purge.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-purge.ts"],"mappings":";;;;;;;;;;;;;;YA2CY;;;;;;EAMV;;;;;EAMA;;;;;;EAOA;;;;;;EAOA;;;;;;EAOA;;;;;EAMA;;;;;EAMA;;;;;;EAOA;;;;;;;;EASA,6BAA6B,YAAY;;;;;;EAOzC,8BAA8B;;;;;;;;;;;;EAgB9B,gBAAgB;;;;;;;EAQhB,YAAY,KAAK;;;;;;;;;;qBAwBN,wBAAqB,oBAAsB;;;;;;;;;;;;;;;;;;qBA0rB3C,2BAAwB,SAC1B,uBACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmIU,2BAAwB;EACnC,cAAc;MACZ"}

package/dist/types/babel-plugin-intlayer-usage-analyzer.d.ts

@@ -1,169 +1,10 @@
-import { NodePath, PluginObject } from "@babel/core";
+import { DictionaryFieldUsage, NestedRenameEntry, NestedRenameMap, OpaqueFieldOccurrence, PruneContext, createPruneContext, preserveNestedDictionaryFields } from "./pruneContext.js";
+import { CHAINABLE_RUNTIME_METHOD_NAMES, INTLAYER_CALLER_NAMES, IntlayerCallerName, NATIVE_CALLER_NAME_SET } from "./nativeCallers.js";
+import { unwrapAwait } from "./staticAstReaders.js";
+import { PluginObject } from "@babel/core";
 import * as BabelTypes from "@babel/types";
 import { CallerDescriptor, CallerDescriptor as CallerDescriptor$1, CallerResultShape, CallerValueSource } from "@intlayer/config/callers";
-import { NestedFieldReferences } from "@intlayer/core/dictionaryManipulator";
 //#region src/babel-plugin-intlayer-usage-analyzer.d.ts
-/**
- * Dictionary field usage result for a single dictionary key.
- *
- *   'all'        → could not determine statically which fields are used;
- *                  keep every field (no pruning possible).
- *   Set<string>  → the exact top-level content field names that were accessed.
- */
-export type DictionaryFieldUsage = Set<string> | 'all';
-/**
- * One node in the nested field-rename tree.
- *
- *   shortName – the compact alias assigned to this field name.
- *   children  – rename table for the next level of user-defined keys inside
- *               this field's value (empty when the value is a leaf / primitive).
- */
-export type NestedRenameEntry = {
-  shortName: string;
-  children: NestedRenameMap;
-};
-/** A level of the field-rename tree, mapping original field names to entries. */
-export type NestedRenameMap = Map<string, NestedRenameEntry>;
-/**
- * One opaque consumption of a dictionary content value: the value at
- * `fieldPath` escapes static analysis (passed as-is to a child component or a
- * function argument), so its children must keep their original key names in
- * the compiled JSON.
- */
-export type OpaqueFieldOccurrence = {
-  /**
-   * Original (pre-rename) user-defined field names from the content root to
-   * the escaping value, e.g. `['sections', 'hero']` for
-   * `<Card data={content.sections.hero} />`.
-   */
-  fieldPath: string[];
-  /** Source locations (`filePath:line`) where the value escapes. */
-  locations: string[];
-};
-/**
- * Shared mutable state created once by the vite plugin and passed by reference
- * to the usage-analyzer (writer) and the prune/minify plugins (readers).
- *
- * All mutations happen during the usage-analysis `buildStart` phase; readers
- * only access this state during the subsequent `transform` phase.
- */
-export type PruneContext = {
-  /**
-   * Maps every dictionary key seen in source files to the set of top-level
-   * content fields statically accessed, or `'all'` when the access pattern
-   * could not be determined.
-   */
-  dictionaryKeyToFieldUsageMap: Map<string, DictionaryFieldUsage>;
-  /**
-   * Dictionary keys for which the prune/minify step must be skipped entirely
-   * because an edge case was detected during analysis or structure recognition.
-   */
-  dictionariesWithEdgeCases: Set<string>;
-  /**
-   * True if at least one source file failed to parse during the analysis phase.
-   * The prune plugin uses this flag conservatively: any dictionary key without
-   * a usage entry might have been referenced by the unparsable file.
-   */
-  hasUnparsableSourceFiles: boolean;
-  /**
-   * Maps dictionary keys to the source file paths where the result of
-   * `useIntlayer` / `getIntlayer` was assigned to a plain variable, making
-   * static field analysis impossible.
-   */
-  dictionaryKeysWithUntrackedBindings: Map<string, string[]>;
-  /**
-   * Maps each dictionary key to a nested field-rename tree built after the
-   * usage analysis phase (only populated when `build.minify` is active and
-   * the field usage for that dictionary is a finite `Set<string>`).
-   */
-  dictionaryKeyToFieldRenameMap: Map<string, NestedRenameMap>;
-  /**
-   * Maps each dictionary key to the content field paths whose values are
-   * consumed "opaquely" (passed as-is to a child component or function
-   * argument). When an opaque value has nested user-defined structure, its
-   * children must not be renamed.
-   *
-   * The inner map is keyed by the dot-joined field path for de-duplication
-   * only; the authoritative path is {@link OpaqueFieldOccurrence.fieldPath}.
-   *
-   * Structure: dictionaryKey → joinedFieldPath → { fieldPath, locations }
-   */
-  dictionaryKeysWithOpaqueFields: Map<string, Map<string, OpaqueFieldOccurrence>>;
-  /**
-   * Dictionary keys for which field-key renaming must be skipped even if a
-   * finite field-usage set was determined.
-   *
-   * Populated for dictionaries whose plain-variable bindings were resolved by
-   * the framework-specific extractor (Vue / Svelte SFCs), because the Babel
-   * rename plugin cannot update the source-code property accesses for those
-   * indirect patterns (Vue `.value.field` / Svelte `$store.field`).
-   *
-   * Pruning and basic minification still apply; only field-key renaming is
-   * suppressed.
-   */
-  dictionariesSkippingFieldRename: Set<string>;
-  /**
-   * Plain variable bindings that require a framework-specific secondary pass.
-   *
-   * Populated during the Babel analysis phase for `.vue` and `.svelte` source
-   * files where direct field access is not visible to Babel scope analysis:
-   *   - Vue:    `content.value.fieldName` – the `.value` ref-accessor is hidden
-   *   - Svelte: `$varName.fieldName`     – the `$` prefix creates a new identifier
-   *
-   * Structure: filePath → [{variableName, dictionaryKey}, …]
-   */
-  pendingFrameworkAnalysis: Map<string, {
-    variableName: string;
-    dictionaryKey: string;
-  }[]>;
-};
-export declare const createPruneContext: () => PruneContext;
-/**
- * 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`.
- */
-export declare const preserveNestedDictionaryFields: (pruneContext: PruneContext, nestedDictionaryReferences: Map<string, NestedFieldReferences>) => void;
-/**
- * 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.
- */
-export declare const CHAINABLE_RUNTIME_METHOD_NAMES: Set<string>;
-/** Canonical intlayer caller names that trigger usage analysis. */
-export declare const INTLAYER_CALLER_NAMES: readonly ['useIntlayer', 'getIntlayer', 'getIntlayerAsync'];
-export type IntlayerCallerName = (typeof INTLAYER_CALLER_NAMES)[number];
 /**
  * Configuration entry for a single compat namespace caller.
  *
@@ -172,42 +13,34 @@ export type IntlayerCallerName = (typeof INTLAYER_CALLER_NAMES)[number];
  */
 export type CompatCallerConfig = CallerDescriptor$1;
 /**
- * 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.
- */
-export declare const DEFAULT_COMPAT_CALLERS: CompatCallerConfig[];
-/**
- * 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.
+ * @deprecated Always empty. Compat callers are injected per build through
+ * `options.compatCallers`; there is no default registry to fall back to.
  */
-export declare const unwrapAwait: (babelTypes: typeof BabelTypes, path: NodePath<BabelTypes.Node>) => NodePath<BabelTypes.Node>;
+export declare const DEFAULT_COMPAT_CALLERS: CallerDescriptor$1[];
 /**
  * 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.
  */
 export declare const makeUsageAnalyzerBabelPlugin: (pruneContext: PruneContext, options?: {
-  compatCallers?: CompatCallerConfig[];
+  compatCallers?: readonly CallerDescriptor$1[];
 }) => ({ types: babelTypes }: {
   types: typeof BabelTypes;
 }) => PluginObject;
 //#endregion
-export type { CallerDescriptor, CallerResultShape, CallerValueSource };
+export { CHAINABLE_RUNTIME_METHOD_NAMES, type CallerDescriptor, type CallerResultShape, type CallerValueSource, type DictionaryFieldUsage, INTLAYER_CALLER_NAMES, type IntlayerCallerName, NATIVE_CALLER_NAME_SET, type NestedRenameEntry, type NestedRenameMap, type OpaqueFieldOccurrence, type PruneContext, createPruneContext, preserveNestedDictionaryFields, unwrapAwait };
 //# sourceMappingURL=babel-plugin-intlayer-usage-analyzer.d.ts.map

package/dist/types/babel-plugin-intlayer-usage-analyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-usage-analyzer.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-usage-analyzer.ts"],"mappings":";;;;;;;;;;;;YAiBY,uBAAuB;;;;;;;;YASvB;EACV;EACA,UAAU;;;YAIA,kBAAkB,YAAY;;;;;;;YAQ9B;;;;;;EAMV;;EAGA;;;;;;;;;YAUU;;;;;;EAMV,8BAA8B,YAAY;;;;;EAM1C,2BAA2B;;;;;;EAO3B;;;;;;EAOA,qCAAqC;;;;;;EAOrC,+BAA+B,YAAY;;;;;;;;;;;;EAa3C,gCAAgC,YAE9B,YAAY;;;;;;;;;;;;;EAed,iCAAiC;;;;;;;;;;;EAYjC,0BAA0B;IAEtB;IAAsB;;;qBAIf,0BAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAyCzB,iCAA8B,cAC3B,cAAY,4BACE,YAAY;;;;;;;;;;;;;;;qBAqD7B,gCAA8B;;qBAG9B;YAKD,6BAA6B;;;;;;;YAmB7B,qBAAqB;;;;;;;;;;;qBAYpB,wBAAwB;;;;;;;qBAWxB,cAAW,mBACH,YAAU,MACvB,SAAS,WAAW,UACzB,SAAS,WAAW;;;;;;;;;;;;;;;qBA8rCV,+BAA4B,cAEvB,cAAY;EACd,gBAAgB;SAAsB,OAAA;EAE1B,cAAc;MAAe"}
+{"version":3,"file":"babel-plugin-intlayer-usage-analyzer.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-usage-analyzer.ts"],"mappings":";;;;;;;;;;;;;YAuCY,qBAAqB;;;;;qBAMpB,wBAAwB;;;;;;;;;;;;;;;;;;;;qBAqBxB,+BAA4B,cAEvB,cAAY;EACd,yBAAyB;SAAoB,OAAA;EAEjC,cAAc;MAAe"}

package/dist/types/compat/namespaceResolution.d.ts

@@ -0,0 +1,66 @@
+import { StaticOrAbsent } from "../staticAstReaders.js";
+import * as BabelTypes from "@babel/types";
+import { CallerDescriptor, CallerValueSource } from "@intlayer/config/callers";
+//#region src/compat/namespaceResolution.d.ts
+/**
+ * Resolution of a compat caller's namespace from its
+ * {@link CallerValueSource} list.
+ *
+ * Two flavours coexist on purpose, because the two passes ask different
+ * questions of the same descriptor:
+ *
+ * - {@link resolveNamespaceForAnalysis} answers *which dictionary does this
+ *   call read* — used by the usage analyser, which only needs to attribute a
+ *   call to a dictionary and may fall back to the caller's default namespace.
+ * - {@link resolveNamespaceForRewrite} answers *can this call be rewritten,
+ *   and where do I edit it* — used by the optimize pass, which needs an exact
+ *   static namespace plus a handle on the node it must replace. It has no
+ *   default-namespace fallback: rewriting a call whose namespace is only
+ *   implied would bind the wrong dictionary.
+ */
+/** Namespace used by compat callers when no namespace argument is given. */
+export declare const DEFAULT_COMPAT_NAMESPACE = "translation";
+/**
+ * Resolves the namespace from a list of `CallerValueSource`s, tried in
+ * declaration order. The first source yielding a static string wins.
+ * Returns {@link ABSENT_VALUE} when every source reports an absent value, and
+ * `undefined` when the namespace is present somewhere but dynamic.
+ */
+export declare const resolveNamespaceForAnalysis: (babelTypes: typeof BabelTypes, callArguments: BabelTypes.CallExpression['arguments'], sources: CallerValueSource[]) => StaticOrAbsent<string>;
+/**
+ * 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.
+ */
+export declare const resolveKeyPrefixForAnalysis: (babelTypes: typeof BabelTypes, callArguments: BabelTypes.CallExpression['arguments'], sources: CallerValueSource[] | undefined) => string | null | undefined;
+/**
+ * Result of statically resolving the namespace of a compat caller call-site
+ * for rewriting, carrying the handles the optimize pass mutates.
+ */
+export type RewritableNamespaceMatch = {
+  /** The full namespace string, e.g. `'about.counter'`. */
+  fullNamespace: string;
+  /** Index of the positional namespace argument, when read from an argument. */
+  argumentIndex?: number;
+  /**
+   * The options-object property holding the namespace, when read from an
+   * option. The rewrite mutates it in place (key-prefix remainder) or removes
+   * it from `optionsObject`.
+   */
+  optionProperty?: BabelTypes.ObjectProperty;
+  /** The options object owning `optionProperty`. */
+  optionsObject?: BabelTypes.ObjectExpression;
+};
+/**
+ * Statically resolves the namespace of a compat caller call-site for the
+ * optimize pass. Only the `argument` / `option` / `fixed` sources qualify: the
+ * per-message-id `path-first-segment` form cannot bind one dictionary to the
+ * call site and is skipped.
+ *
+ * Returns `undefined` when the namespace is absent or dynamic, in which case
+ * the call is left untouched and resolves through the runtime dictionary
+ * registry.
+ */
+export declare const resolveNamespaceForRewrite: (babelTypes: typeof BabelTypes, callArguments: BabelTypes.CallExpression['arguments'], descriptor: CallerDescriptor) => RewritableNamespaceMatch | undefined;
+//#endregion
+//# sourceMappingURL=namespaceResolution.d.ts.map

package/dist/types/compat/namespaceResolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespaceResolution.d.ts","names":[],"sources":["../../../src/compat/namespaceResolution.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;qBAiCa;;;;;;;qBAoEA,8BAA2B,mBACnB,YAAU,eACd,WAAW,6BAA2B,SAC5C,wBACR;;;;;;qBAuBU,8BAA2B,mBACnB,YAAU,eACd,WAAW,6BAA2B,SAC5C;;;;;YAiBC;;EAEV;;EAEA;;;;;;EAMA,iBAAiB,WAAW;;EAE5B,gBAAgB,WAAW;;;;;;;;;;;;qBAahB,6BAA0B,mBAClB,YAAU,eACd,WAAW,6BAA2B,YACzC,qBACX"}

package/dist/types/compat/optimizePass.d.ts

@@ -0,0 +1,58 @@
+import { DictionaryImportRegistry, ImportMode } from "../dictionaryImports.js";
+import * as BabelTypes from "@babel/types";
+import { CallerDescriptor } from "@intlayer/config/callers";
+//#region src/compat/optimizePass.d.ts
+/**
+ * Compat half of the optimize pass.
+ *
+ * Every adapter-specific behaviour of the build-time rewrite lives here:
+ * matching a compat caller's import, resolving its namespace, and re-pointing
+ * the import specifier at the dictionary-accepting helper.
+ *
+ * The pass works on plain AST nodes rather than `NodePath`s: the optimize
+ * plugin collects the call sites in its single traversal and hands them over,
+ * so nothing here walks the tree.
+ *
+ * It is created only when compat descriptors were injected by a compat
+ * package's bundler plugin, so a plain intlayer build never allocates it —
+ * {@link createCompatOptimizePass} returns `null` for an empty registry.
+ */
+export type CompatOptimizePass = {
+  /**
+   * Whether `importSource` exports at least one rewritable compat caller, so
+   * the optimize plugin knows the import is worth inspecting even though it is
+   * not a native intlayer package.
+   */
+  ownsImportSource: (importSource: string) => boolean;
+  /** Records the local alias one import specifier introduces. */
+  noteImport: (importSource: string, importedName: string, localName: string) => void;
+  /** Whether `localName` was bound to a compat caller by an import. */
+  ownsLocalName: (localName: string) => boolean;
+  /** Whether the file imported any compat caller at all. */
+  hasCallers: () => boolean;
+  /**
+   * Resolves the namespace of every collected call, dropping the callers that
+   * cannot be rewritten and deciding the file-level helper family. Must run
+   * after every import was noted and before any rewrite.
+   */
+  analyzeCalls: (callNodes: readonly BabelTypes.CallExpression[]) => void;
+  /** Rewrites one compat call site, if its caller survived {@link analyzeCalls}. */
+  rewriteCall: (callNode: BabelTypes.CallExpression) => void;
+  /** Re-points the compat specifiers of one import declaration. */
+  rewriteImportSpecifiers: (importNode: BabelTypes.ImportDeclaration) => void;
+};
+/**
+ * Builds the compat optimize pass for one source file, or `null` when no
+ * compat caller was injected.
+ *
+ * @param babelTypes - Babel's type helpers.
+ * @param compatCallers - Descriptors injected by the compat packages' plugins.
+ * @param imports - Shared dictionary-import registry for the file.
+ * @param buildModes - The file's global import mode and per-dictionary overrides.
+ */
+export declare const createCompatOptimizePass: (babelTypes: typeof BabelTypes, compatCallers: readonly CallerDescriptor[], imports: DictionaryImportRegistry, buildModes: {
+  importMode: ImportMode | undefined;
+  dictionaryModeMap?: Record<string, ImportMode | undefined>;
+}) => CompatOptimizePass | null;
+//#endregion
+//# sourceMappingURL=optimizePass.d.ts.map

package/dist/types/compat/optimizePass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimizePass.d.ts","names":[],"sources":["../../../src/compat/optimizePass.ts"],"mappings":";;;;;;;;;;;;;;;;;;;YA2BY;;;;;;EAMV,mBAAmB;;EAEnB,aACE,sBACA,sBACA;;EAGF,gBAAgB;;EAEhB;;;;;;EAMA,eAAe,oBAAoB,WAAW;;EAE9C,cAAc,UAAU,WAAW;;EAEnC,0BAA0B,YAAY,WAAW;;;;;;;;;;;qBA4EtC,2BAAwB,mBAChB,YAAU,wBACL,oBAAkB,SACjC,0BAAwB;EAE/B,YAAY;EACZ,oBAAoB,eAAe;MAEpC"}