@intlayer/babel 9.0.0-canary.11 → 9.0.0-canary.13

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

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-field-rename.mjs","names":[],"sources":["../../src/babel-plugin-intlayer-field-rename.ts"],"sourcesContent":["import type { NodePath, PluginObject } from '@babel/core';\nimport type * as BabelTypes from '@babel/types';\nimport {\n  INTLAYER_CALLER_NAMES,\n  type IntlayerCallerName,\n  type NestedRenameMap,\n  type PruneContext,\n} from './babel-plugin-intlayer-usage-analyzer';\n\n// ── Field-name helpers ────────────────────────────────────────────────────────\n\n/**\n * Intlayer internal property names that must never be used as short-name\n * targets. These appear inside content-node values (e.g. `{ nodeType:\n * \"translation\", … }`) and are read by the intlayer runtime.\n */\nconst RESERVED_CONTENT_FIELD_NAMES = new Set(['nodeType']);\n\n/**\n * Converts a zero-based index to a short alphabetic identifier.\n *   0 → 'a', 1 → 'b', …, 25 → 'z', 26 → 'aa', 27 → 'ab', …\n */\nexport const generateShortFieldName = (index: number): string => {\n  const ALPHABET = 'abcdefghijklmnopqrstuvwxyz';\n  const remainder = index % ALPHABET.length;\n  const quotient = Math.floor(index / ALPHABET.length);\n\n  return quotient === 0 && ALPHABET[remainder]\n    ? ALPHABET[remainder]\n    : generateShortFieldName(quotient - 1) + ALPHABET[remainder];\n};\n\n/**\n * Recursively builds a `NestedRenameMap` from a compiled dictionary content\n * value by traversing the intlayer node structure.\n *\n * Rules:\n *  - If the value has `nodeType: 'translation'`, user-defined fields live\n *    inside `translation[locale]`. Recurse into the first locale's value.\n *  - All other intlayer runtime nodes (enumeration, condition, gender, …) are\n *    treated as leaves — their internal keys must never be renamed.\n *  - Arrays produce an empty children map.  Array elements are not traversed\n *    because consumers may access them via `.map()` / `.filter()` callbacks,\n *    which the source-code rename walk cannot enter.  Renaming element fields\n *    in the JSON without the matching source-code rename would produce\n *    mismatched key names and runtime crashes.\n *    The `[0]` pass-through in `walkRenameChain` is preserved so that direct\n *    indexed access (`field[0].sub`) silently terminates at the empty children\n *    map without breaking anything.\n *  - Plain objects are user-defined records: ALL non-reserved keys are renamed\n *    with short alphabetic aliases (a, b, c, …) and each value is recursed into.\n *  - Primitives produce an empty map (no further renaming).\n *\n * The rename map is built from ALL user-defined fields (not just consumed ones).\n * Both the JSON rename and the source-code rename use the same map, so the\n * short names are always consistent regardless of which fields are pruned.\n *\n * @param contentValue - The dictionary content value to analyse.\n */\nexport const buildNestedRenameMapFromContent = (\n  contentValue: unknown\n): NestedRenameMap => {\n  if (\n    !contentValue ||\n    typeof contentValue !== 'object' ||\n    Array.isArray(contentValue)\n  ) {\n    return new Map();\n  }\n\n  const record = contentValue as Record<string, unknown>;\n\n  // Any object with `nodeType: string` is an intlayer runtime node.\n  if (typeof record.nodeType === 'string') {\n    // Translation node: user-defined fields live inside translation[locale].\n    if (\n      record.nodeType === 'translation' &&\n      record.translation &&\n      typeof record.translation === 'object' &&\n      !Array.isArray(record.translation)\n    ) {\n      const firstLocaleValue = Object.values(\n        record.translation as Record<string, unknown>\n      )[0];\n      return buildNestedRenameMapFromContent(firstLocaleValue);\n    }\n\n    // Enumeration node: user-defined keys live inside enumeration.\n    if (\n      record.nodeType === 'enumeration' &&\n      record.enumeration &&\n      typeof record.enumeration === 'object' &&\n      !Array.isArray(record.enumeration)\n    ) {\n      const values = Object.values(\n        record.enumeration as Record<string, unknown>\n      );\n      if (values.length > 0) {\n        return buildNestedRenameMapFromContent(values[0]);\n      }\n    }\n\n    // All other intlayer nodes (pluralization, conditions, etc.) resolve to a\n    // single value at runtime – return an empty map so they are treated\n    // as leaves unless they contain nested user records.\n    return new Map();\n  }\n\n  // Exclude React elements from being treated as user-defined records.\n  // JSX elements in the compiled JSON have a $$typeof property (usually Symbol(react.element)).\n  if (\n    record.$$typeof ||\n    (record.type && record.props && Object.hasOwn(record, 'ref'))\n  ) {\n    return new Map();\n  }\n\n  // User-defined record: rename ALL non-reserved keys with stable alphabetic\n  // aliases sorted alphabetically so the mapping is deterministic.\n  const sortedKeys = Object.keys(record)\n    .filter((key) => !RESERVED_CONTENT_FIELD_NAMES.has(key))\n    .sort();\n\n  const renameMap: NestedRenameMap = new Map();\n\n  for (let i = 0; i < sortedKeys.length; i++) {\n    const key = sortedKeys[i];\n\n    if (!key) continue;\n\n    const children = buildNestedRenameMapFromContent(record[key]);\n\n    renameMap.set(key, { shortName: generateShortFieldName(i), children });\n  }\n\n  return renameMap;\n};\n\n// ── Field-rename Babel plugin ─────────────────────────────────────────────────\n\n/**\n * Walks a MemberExpression chain starting from `startPath`, renaming each\n * property found in `currentRenameMap` at the corresponding nesting level.\n *\n * Numeric computed accesses (array indices such as `[0]`, `[1]`) are treated\n * as transparent pass-throughs: the rename map is kept unchanged and the walk\n * continues past the index.  This means `content.field[0].sub` is handled\n * correctly — `field` and `sub` are both renamed while `[0]` is left intact.\n */\nconst walkRenameChain = (\n  babelTypes: typeof BabelTypes,\n  startPath: NodePath<BabelTypes.Node>,\n  currentRenameMap: NestedRenameMap\n): {\n  finalPath: NodePath<BabelTypes.Node>;\n  finalRenameMap: NestedRenameMap;\n} => {\n  let refPath: NodePath<BabelTypes.Node> = startPath;\n  let renameMap = currentRenameMap;\n\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    const parentPath = refPath.parentPath;\n    if (!parentPath) break;\n\n    const parentNode = parentPath.node;\n\n    if (\n      (!babelTypes.isMemberExpression(parentNode) &&\n        !babelTypes.isOptionalMemberExpression(parentNode)) ||\n      (parentNode as BabelTypes.MemberExpression).object !== refPath.node\n    ) {\n      break;\n    }\n\n    const memberNode = parentNode as BabelTypes.MemberExpression;\n\n    // Numeric index access ([0], [1], …): advance past the array accessor\n    // without touching the rename map.  The next iteration will attempt to\n    // rename the property that follows the index.\n    if (\n      memberNode.computed &&\n      babelTypes.isNumericLiteral(memberNode.property)\n    ) {\n      refPath = parentPath;\n      continue;\n    }\n\n    // Nothing left to rename at this level — stop.\n    if (renameMap.size === 0) break;\n\n    let fieldName: string | undefined;\n\n    if (!memberNode.computed && babelTypes.isIdentifier(memberNode.property)) {\n      fieldName = memberNode.property.name;\n    } else if (\n      memberNode.computed &&\n      babelTypes.isStringLiteral(memberNode.property)\n    ) {\n      fieldName = memberNode.property.value;\n    } else {\n      break; // dynamic computed key – stop\n    }\n\n    const renameEntry = renameMap.get(fieldName);\n    if (!renameEntry) break; // not in map – stop\n\n    // Apply the rename\n    if (!memberNode.computed && babelTypes.isIdentifier(memberNode.property)) {\n      memberNode.property.name = renameEntry.shortName;\n    } else if (\n      memberNode.computed &&\n      babelTypes.isStringLiteral(memberNode.property)\n    ) {\n      memberNode.property.value = renameEntry.shortName;\n    }\n\n    refPath = parentPath;\n    renameMap = renameEntry.children;\n  }\n\n  return { finalPath: refPath, finalRenameMap: renameMap };\n};\n\n/**\n * Walks an object-destructuring assignment whose right-hand side is `refPath`,\n * renaming each destructured key that is found in `renameMap`.\n *\n * Handles the \"secondary destructuring\" pattern that `walkRenameChain` cannot\n * reach because the reference is not a MemberExpression:\n *\n *   const { webhooksSection } = useIntlayer('build-settings');\n *   const { modal, validationErrors } = webhooksSection;\n *     → const { a: modal, b: validationErrors } = webhooksSection;\n *\n * After renaming each key the function recursively walks references to the\n * newly-bound local variable, calling both `walkRenameChain` (for subsequent\n * member-access chains like `validationErrors.invalidUrl`) and itself (for\n * further levels of secondary destructuring).\n */\nconst walkObjectDestructuring = (\n  babelTypes: typeof BabelTypes,\n  refPath: NodePath<BabelTypes.Node>,\n  renameMap: NestedRenameMap\n): void => {\n  if (renameMap.size === 0) return;\n\n  const parentNode = refPath.parent;\n\n  // Only handle:  const { a, b } = refVar\n  if (\n    !babelTypes.isVariableDeclarator(parentNode) ||\n    !babelTypes.isObjectPattern(parentNode.id) ||\n    parentNode.init !== refPath.node\n  ) {\n    return;\n  }\n\n  for (const property of (parentNode.id as BabelTypes.ObjectPattern)\n    .properties) {\n    if (!babelTypes.isObjectProperty(property)) continue;\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 renameEntry = renameMap.get(keyName);\n    if (!renameEntry) continue;\n\n    // { fieldA } → { shortA: fieldA }\n    // { fieldA: localVar } → { shortA: localVar }\n    if (property.shorthand) {\n      property.shorthand = false;\n    }\n    property.key = babelTypes.identifier(renameEntry.shortName);\n\n    // Recursively walk references to the local variable bound by this key.\n    if (\n      renameEntry.children.size > 0 &&\n      babelTypes.isIdentifier(property.value)\n    ) {\n      const localVarName = (property.value as BabelTypes.Identifier).name;\n      const localVarBinding = refPath.scope.getBinding(localVarName);\n      if (localVarBinding) {\n        for (const nestedRefPath of localVarBinding.referencePaths) {\n          const { finalPath, finalRenameMap } = walkRenameChain(\n            babelTypes,\n            nestedRefPath,\n            renameEntry.children\n          );\n          walkObjectDestructuring(babelTypes, finalPath, finalRenameMap);\n        }\n      }\n    }\n  }\n};\n\n/**\n * Creates a Babel plugin that rewrites dictionary content field accesses in\n * source files to their short aliases defined in\n * `pruneContext.dictionaryKeyToFieldRenameMap`.\n *\n * Handled patterns (mirrors the usage analyser):\n *\n *   const { fieldA, fieldB } = useIntlayer('key')\n *     → const { shortA: fieldA, shortB: fieldB } = useIntlayer('key')\n *\n *   useIntlayer('key').fieldA\n *     → useIntlayer('key').shortA\n *\n *   const result = useIntlayer('key');  result.fieldA\n *     → const result = useIntlayer('key');  result.shortA\n *\n *   const { fieldA } = useIntlayer('key');\n *   const { nested } = fieldA;          // secondary destructuring\n *     → const { shortA: fieldA } = useIntlayer('key');\n *       const { shortN: nested } = fieldA;\n *\n * This plugin must run in a separate `transformAsync` pass **before**\n * `intlayerOptimizeBabelPlugin`, because the latter replaces `useIntlayer`\n * with `useDictionary`, erasing the dictionary-key information needed here.\n */\nexport const makeFieldRenameBabelPlugin =\n  (pruneContext: PruneContext) =>\n  ({ types: babelTypes }: { types: typeof BabelTypes }): PluginObject => ({\n    name: 'intlayer-field-rename',\n    visitor: {\n      Program: {\n        exit: (programPath) => {\n          if (pruneContext.dictionaryKeyToFieldRenameMap.size === 0) return;\n\n          // Collect local aliases for useIntlayer / getIntlayer\n          const intlayerCallerLocalNameMap = new Map<string, string>();\n\n          programPath.traverse({\n            ImportDeclaration: (importDeclarationPath) => {\n              for (const importSpecifier of importDeclarationPath.node\n                .specifiers) {\n                if (!babelTypes.isImportSpecifier(importSpecifier)) continue;\n\n                const importedName = babelTypes.isIdentifier(\n                  importSpecifier.imported\n                )\n                  ? importSpecifier.imported.name\n                  : (importSpecifier.imported as BabelTypes.StringLiteral)\n                      .value;\n\n                if (\n                  INTLAYER_CALLER_NAMES.includes(\n                    importedName as IntlayerCallerName\n                  )\n                ) {\n                  intlayerCallerLocalNameMap.set(\n                    importSpecifier.local.name,\n                    importedName\n                  );\n                }\n              }\n            },\n          });\n\n          if (intlayerCallerLocalNameMap.size === 0) return;\n\n          // Visit all useIntlayer / getIntlayer call-sites and rename field accesses\n          programPath.traverse({\n            CallExpression: (callExpressionPath) => {\n              const calleeNode = callExpressionPath.node.callee;\n              let localCallerName: string | undefined;\n\n              if (babelTypes.isIdentifier(calleeNode)) {\n                localCallerName = calleeNode.name;\n              } else if (\n                babelTypes.isMemberExpression(calleeNode) &&\n                babelTypes.isIdentifier(calleeNode.property)\n              ) {\n                localCallerName = calleeNode.property.name;\n              }\n\n              if (\n                !localCallerName ||\n                !intlayerCallerLocalNameMap.has(localCallerName)\n              )\n                return;\n\n              const callArguments = callExpressionPath.node.arguments;\n              if (callArguments.length === 0) return;\n\n              const firstArgument = callArguments[0];\n              let dictionaryKey: string | undefined;\n\n              if (babelTypes.isStringLiteral(firstArgument)) {\n                dictionaryKey = firstArgument.value;\n              } else if (\n                babelTypes.isTemplateLiteral(firstArgument) &&\n                firstArgument.expressions.length === 0 &&\n                firstArgument.quasis.length === 1 &&\n                firstArgument.quasis[0]\n              ) {\n                dictionaryKey =\n                  firstArgument.quasis[0].value.cooked ??\n                  firstArgument.quasis[0].value.raw;\n              }\n\n              if (!dictionaryKey) return;\n\n              const fieldRenameMap =\n                pruneContext.dictionaryKeyToFieldRenameMap.get(dictionaryKey);\n              if (!fieldRenameMap || fieldRenameMap.size === 0) return;\n\n              const parentNode = callExpressionPath.parent;\n\n              // ── Case 1: const { fieldA, fieldB } = useIntlayer('key') ────────\n              if (\n                babelTypes.isVariableDeclarator(parentNode) &&\n                babelTypes.isObjectPattern(parentNode.id)\n              ) {\n                for (const property of parentNode.id.properties) {\n                  if (!babelTypes.isObjectProperty(property)) continue;\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 renameEntry = fieldRenameMap.get(keyName);\n                  if (!renameEntry) continue;\n\n                  // { fieldA } → { shortA: fieldA }\n                  // { fieldA: localVar } → { shortA: localVar }\n                  if (property.shorthand) {\n                    property.shorthand = false;\n                    property.key = babelTypes.identifier(renameEntry.shortName);\n                  } else {\n                    property.key = babelTypes.identifier(renameEntry.shortName);\n                  }\n\n                  // Walk nested member accesses and secondary destructurings\n                  // on the local variable.\n                  if (\n                    renameEntry.children.size > 0 &&\n                    babelTypes.isIdentifier(property.value)\n                  ) {\n                    const localVarBinding = callExpressionPath.scope.getBinding(\n                      (property.value as BabelTypes.Identifier).name\n                    );\n                    if (localVarBinding) {\n                      for (const refPath of localVarBinding.referencePaths) {\n                        const { finalPath, finalRenameMap } = walkRenameChain(\n                          babelTypes,\n                          refPath,\n                          renameEntry.children\n                        );\n                        walkObjectDestructuring(\n                          babelTypes,\n                          finalPath,\n                          finalRenameMap\n                        );\n                      }\n                    }\n                  }\n                }\n                return;\n              }\n\n              // ── Case 2: useIntlayer('key').fieldA.nested ─────────────────────\n              if (\n                (babelTypes.isMemberExpression(parentNode) ||\n                  babelTypes.isOptionalMemberExpression(parentNode)) &&\n                (parentNode as BabelTypes.MemberExpression).object ===\n                  callExpressionPath.node\n              ) {\n                const { finalPath, finalRenameMap } = walkRenameChain(\n                  babelTypes,\n                  callExpressionPath,\n                  fieldRenameMap\n                );\n                walkObjectDestructuring(babelTypes, finalPath, finalRenameMap);\n                return;\n              }\n\n              // ── Case 3: const result = useIntlayer('key'); result.fieldA ─────\n              if (\n                babelTypes.isVariableDeclarator(parentNode) &&\n                babelTypes.isIdentifier(parentNode.id)\n              ) {\n                const variableName = parentNode.id.name;\n                const variableBinding =\n                  callExpressionPath.scope.getBinding(variableName);\n                if (!variableBinding) return;\n\n                for (const variableReferencePath of variableBinding.referencePaths) {\n                  // Direct access: result.fieldA or const { fieldA } = result\n                  const { finalPath, finalRenameMap } = walkRenameChain(\n                    babelTypes,\n                    variableReferencePath,\n                    fieldRenameMap\n                  );\n                  walkObjectDestructuring(\n                    babelTypes,\n                    finalPath,\n                    finalRenameMap\n                  );\n\n                  // Signal accessor: result().fieldA or const { fieldA } = result()\n                  // walkRenameChain stops at a CallExpression parent, so we need to\n                  // start a new walk from the call-expression node itself.\n                  const refParent = variableReferencePath.parent;\n                  if (\n                    (babelTypes.isCallExpression(refParent) ||\n                      babelTypes.isOptionalCallExpression(refParent)) &&\n                    (refParent as BabelTypes.CallExpression).callee ===\n                      variableReferencePath.node\n                  ) {\n                    const callPath = variableReferencePath.parentPath;\n                    if (callPath) {\n                      const {\n                        finalPath: signalFinalPath,\n                        finalRenameMap: signalFinalRenameMap,\n                      } = walkRenameChain(babelTypes, callPath, fieldRenameMap);\n                      walkObjectDestructuring(\n                        babelTypes,\n                        signalFinalPath,\n                        signalFinalRenameMap\n                      );\n                    }\n                  }\n                }\n              }\n            },\n          });\n        },\n      },\n    },\n  });\n"],"mappings":"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"}
+{"version":3,"file":"babel-plugin-intlayer-field-rename.mjs","names":[],"sources":["../../src/babel-plugin-intlayer-field-rename.ts"],"sourcesContent":["import type { NodePath, PluginObject } from '@babel/core';\nimport type * as BabelTypes from '@babel/types';\nimport {\n  INTLAYER_CALLER_NAMES,\n  type IntlayerCallerName,\n  type NestedRenameMap,\n  type PruneContext,\n} from './babel-plugin-intlayer-usage-analyzer';\n\n// ── Field-name helpers ────────────────────────────────────────────────────────\n\n/**\n * Intlayer internal property names that must never be used as short-name\n * targets. These appear inside content-node values (e.g. `{ nodeType:\n * \"translation\", … }`) and are read by the intlayer runtime.\n */\nconst RESERVED_CONTENT_FIELD_NAMES = new Set(['nodeType']);\n\n/** Alphabet used to derive short field aliases (`a`, `b`, …, `aa`, `ab`, …). */\nconst SHORT_NAME_ALPHABET = 'abcdefghijklmnopqrstuvwxyz';\n\n/**\n * Converts a zero-based index to a short alphabetic identifier.\n *   0 → 'a', 1 → 'b', …, 25 → 'z', 26 → 'aa', 27 → 'ab', …\n */\nexport const generateShortFieldName = (index: number): string => {\n  const remainder = index % SHORT_NAME_ALPHABET.length;\n  const quotient = Math.floor(index / SHORT_NAME_ALPHABET.length);\n\n  return quotient === 0 && SHORT_NAME_ALPHABET[remainder]\n    ? SHORT_NAME_ALPHABET[remainder]\n    : generateShortFieldName(quotient - 1) + SHORT_NAME_ALPHABET[remainder];\n};\n\n/**\n * Recursively builds a `NestedRenameMap` from a compiled dictionary content\n * value by traversing the intlayer node structure.\n *\n * Rules:\n *  - If the value has `nodeType: 'translation'`, user-defined fields live\n *    inside `translation[locale]`. Recurse into the first locale's value.\n *  - All other intlayer runtime nodes (enumeration, condition, gender, …) are\n *    treated as leaves — their internal keys must never be renamed.\n *  - Arrays produce an empty children map.  Array elements are not traversed\n *    because consumers may access them via `.map()` / `.filter()` callbacks,\n *    which the source-code rename walk cannot enter.  Renaming element fields\n *    in the JSON without the matching source-code rename would produce\n *    mismatched key names and runtime crashes.\n *    The `[0]` pass-through in `walkRenameChain` is preserved so that direct\n *    indexed access (`field[0].sub`) silently terminates at the empty children\n *    map without breaking anything.\n *  - Plain objects are user-defined records: ALL non-reserved keys are renamed\n *    with short alphabetic aliases (a, b, c, …) and each value is recursed into.\n *  - Primitives produce an empty map (no further renaming).\n *\n * The rename map is built from ALL user-defined fields (not just consumed ones).\n * Both the JSON rename and the source-code rename use the same map, so the\n * short names are always consistent regardless of which fields are pruned.\n *\n * @param contentValue - The dictionary content value to analyse.\n */\nexport const buildNestedRenameMapFromContent = (\n  contentValue: unknown\n): NestedRenameMap => {\n  if (\n    !contentValue ||\n    typeof contentValue !== 'object' ||\n    Array.isArray(contentValue)\n  ) {\n    return new Map();\n  }\n\n  const record = contentValue as Record<string, unknown>;\n\n  // Any object with `nodeType: string` is an intlayer runtime node.\n  if (typeof record.nodeType === 'string') {\n    // Translation node: user-defined fields live inside translation[locale].\n    if (\n      record.nodeType === 'translation' &&\n      record.translation &&\n      typeof record.translation === 'object' &&\n      !Array.isArray(record.translation)\n    ) {\n      const firstLocaleValue = Object.values(\n        record.translation as Record<string, unknown>\n      )[0];\n      return buildNestedRenameMapFromContent(firstLocaleValue);\n    }\n\n    // Enumeration node: user-defined keys live inside enumeration.\n    if (\n      record.nodeType === 'enumeration' &&\n      record.enumeration &&\n      typeof record.enumeration === 'object' &&\n      !Array.isArray(record.enumeration)\n    ) {\n      const values = Object.values(\n        record.enumeration as Record<string, unknown>\n      );\n      if (values.length > 0) {\n        return buildNestedRenameMapFromContent(values[0]);\n      }\n    }\n\n    // All other intlayer nodes (pluralization, conditions, etc.) resolve to a\n    // single value at runtime – return an empty map so they are treated\n    // as leaves unless they contain nested user records.\n    return new Map();\n  }\n\n  // Exclude React elements from being treated as user-defined records.\n  // JSX elements in the compiled JSON have a $$typeof property (usually Symbol(react.element)).\n  if (\n    record.$$typeof ||\n    (record.type && record.props && Object.hasOwn(record, 'ref'))\n  ) {\n    return new Map();\n  }\n\n  // User-defined record: rename ALL non-reserved keys with stable alphabetic\n  // aliases sorted alphabetically so the mapping is deterministic.\n  const sortedKeys = Object.keys(record)\n    .filter((key) => !RESERVED_CONTENT_FIELD_NAMES.has(key))\n    .sort();\n\n  const renameMap: NestedRenameMap = new Map();\n\n  for (let i = 0; i < sortedKeys.length; i++) {\n    const key = sortedKeys[i];\n\n    if (!key) continue;\n\n    const children = buildNestedRenameMapFromContent(record[key]);\n\n    renameMap.set(key, { shortName: generateShortFieldName(i), children });\n  }\n\n  return renameMap;\n};\n\n// ── Field-rename Babel plugin ─────────────────────────────────────────────────\n\n/**\n * Walks a MemberExpression chain starting from `startPath`, renaming each\n * property found in `currentRenameMap` at the corresponding nesting level.\n *\n * Numeric computed accesses (array indices such as `[0]`, `[1]`) are treated\n * as transparent pass-throughs: the rename map is kept unchanged and the walk\n * continues past the index.  This means `content.field[0].sub` is handled\n * correctly — `field` and `sub` are both renamed while `[0]` is left intact.\n */\nconst walkRenameChain = (\n  babelTypes: typeof BabelTypes,\n  startPath: NodePath<BabelTypes.Node>,\n  currentRenameMap: NestedRenameMap\n): {\n  finalPath: NodePath<BabelTypes.Node>;\n  finalRenameMap: NestedRenameMap;\n} => {\n  let refPath: NodePath<BabelTypes.Node> = startPath;\n  let renameMap = currentRenameMap;\n\n  while (true) {\n    const parentPath = refPath.parentPath;\n    if (!parentPath) break;\n\n    const parentNode = parentPath.node;\n\n    if (\n      (!babelTypes.isMemberExpression(parentNode) &&\n        !babelTypes.isOptionalMemberExpression(parentNode)) ||\n      (parentNode as BabelTypes.MemberExpression).object !== refPath.node\n    ) {\n      break;\n    }\n\n    const memberNode = parentNode as BabelTypes.MemberExpression;\n\n    // Numeric index access ([0], [1], …): advance past the array accessor\n    // without touching the rename map.  The next iteration will attempt to\n    // rename the property that follows the index.\n    if (\n      memberNode.computed &&\n      babelTypes.isNumericLiteral(memberNode.property)\n    ) {\n      refPath = parentPath;\n      continue;\n    }\n\n    // Nothing left to rename at this level — stop.\n    if (renameMap.size === 0) break;\n\n    let fieldName: string | undefined;\n\n    if (!memberNode.computed && babelTypes.isIdentifier(memberNode.property)) {\n      fieldName = memberNode.property.name;\n    } else if (\n      memberNode.computed &&\n      babelTypes.isStringLiteral(memberNode.property)\n    ) {\n      fieldName = memberNode.property.value;\n    } else {\n      break; // dynamic computed key – stop\n    }\n\n    const renameEntry = renameMap.get(fieldName);\n    if (!renameEntry) break; // not in map – stop\n\n    // Apply the rename\n    if (!memberNode.computed && babelTypes.isIdentifier(memberNode.property)) {\n      memberNode.property.name = renameEntry.shortName;\n    } else if (\n      memberNode.computed &&\n      babelTypes.isStringLiteral(memberNode.property)\n    ) {\n      memberNode.property.value = renameEntry.shortName;\n    }\n\n    refPath = parentPath;\n    renameMap = renameEntry.children;\n  }\n\n  return { finalPath: refPath, finalRenameMap: renameMap };\n};\n\n/**\n * Walks an object-destructuring assignment whose right-hand side is `refPath`,\n * renaming each destructured key that is found in `renameMap`.\n *\n * Handles the \"secondary destructuring\" pattern that `walkRenameChain` cannot\n * reach because the reference is not a MemberExpression:\n *\n *   const { webhooksSection } = useIntlayer('build-settings');\n *   const { modal, validationErrors } = webhooksSection;\n *     → const { a: modal, b: validationErrors } = webhooksSection;\n *\n * After renaming each key the function recursively walks references to the\n * newly-bound local variable, calling both `walkRenameChain` (for subsequent\n * member-access chains like `validationErrors.invalidUrl`) and itself (for\n * further levels of secondary destructuring).\n */\nconst walkObjectDestructuring = (\n  babelTypes: typeof BabelTypes,\n  refPath: NodePath<BabelTypes.Node>,\n  renameMap: NestedRenameMap\n): void => {\n  if (renameMap.size === 0) return;\n\n  const parentNode = refPath.parent;\n\n  // Only handle:  const { a, b } = refVar\n  if (\n    !babelTypes.isVariableDeclarator(parentNode) ||\n    !babelTypes.isObjectPattern(parentNode.id) ||\n    parentNode.init !== refPath.node\n  ) {\n    return;\n  }\n\n  for (const property of (parentNode.id as BabelTypes.ObjectPattern)\n    .properties) {\n    if (!babelTypes.isObjectProperty(property)) continue;\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 renameEntry = renameMap.get(keyName);\n    if (!renameEntry) continue;\n\n    // { fieldA } → { shortA: fieldA }\n    // { fieldA: localVar } → { shortA: localVar }\n    if (property.shorthand) {\n      property.shorthand = false;\n    }\n    property.key = babelTypes.identifier(renameEntry.shortName);\n\n    // Recursively walk references to the local variable bound by this key.\n    if (\n      renameEntry.children.size > 0 &&\n      babelTypes.isIdentifier(property.value)\n    ) {\n      const localVarName = (property.value as BabelTypes.Identifier).name;\n      const localVarBinding = refPath.scope.getBinding(localVarName);\n      if (localVarBinding) {\n        for (const nestedRefPath of localVarBinding.referencePaths) {\n          const { finalPath, finalRenameMap } = walkRenameChain(\n            babelTypes,\n            nestedRefPath,\n            renameEntry.children\n          );\n          walkObjectDestructuring(babelTypes, finalPath, finalRenameMap);\n        }\n      }\n    }\n  }\n};\n\n/**\n * Creates a Babel plugin that rewrites dictionary content field accesses in\n * source files to their short aliases defined in\n * `pruneContext.dictionaryKeyToFieldRenameMap`.\n *\n * Handled patterns (mirrors the usage analyser):\n *\n *   const { fieldA, fieldB } = useIntlayer('key')\n *     → const { shortA: fieldA, shortB: fieldB } = useIntlayer('key')\n *\n *   useIntlayer('key').fieldA\n *     → useIntlayer('key').shortA\n *\n *   const result = useIntlayer('key');  result.fieldA\n *     → const result = useIntlayer('key');  result.shortA\n *\n *   const { fieldA } = useIntlayer('key');\n *   const { nested } = fieldA;          // secondary destructuring\n *     → const { shortA: fieldA } = useIntlayer('key');\n *       const { shortN: nested } = fieldA;\n *\n * This plugin must run in a separate `transformAsync` pass **before**\n * `intlayerOptimizeBabelPlugin`, because the latter replaces `useIntlayer`\n * with `useDictionary`, erasing the dictionary-key information needed here.\n */\nexport const makeFieldRenameBabelPlugin =\n  (pruneContext: PruneContext) =>\n  ({ types: babelTypes }: { types: typeof BabelTypes }): PluginObject => ({\n    name: 'intlayer-field-rename',\n    visitor: {\n      Program: {\n        exit: (programPath) => {\n          if (pruneContext.dictionaryKeyToFieldRenameMap.size === 0) return;\n\n          // Collect local aliases for useIntlayer / getIntlayer\n          const intlayerCallerLocalNameMap = new Map<string, string>();\n\n          programPath.traverse({\n            ImportDeclaration: (importDeclarationPath) => {\n              for (const importSpecifier of importDeclarationPath.node\n                .specifiers) {\n                if (!babelTypes.isImportSpecifier(importSpecifier)) continue;\n\n                const importedName = babelTypes.isIdentifier(\n                  importSpecifier.imported\n                )\n                  ? importSpecifier.imported.name\n                  : (importSpecifier.imported as BabelTypes.StringLiteral)\n                      .value;\n\n                if (\n                  INTLAYER_CALLER_NAMES.includes(\n                    importedName as IntlayerCallerName\n                  )\n                ) {\n                  intlayerCallerLocalNameMap.set(\n                    importSpecifier.local.name,\n                    importedName\n                  );\n                }\n              }\n            },\n          });\n\n          if (intlayerCallerLocalNameMap.size === 0) return;\n\n          // Visit all useIntlayer / getIntlayer call-sites and rename field accesses\n          programPath.traverse({\n            CallExpression: (callExpressionPath) => {\n              const calleeNode = callExpressionPath.node.callee;\n              let localCallerName: string | undefined;\n\n              if (babelTypes.isIdentifier(calleeNode)) {\n                localCallerName = calleeNode.name;\n              } else if (\n                babelTypes.isMemberExpression(calleeNode) &&\n                babelTypes.isIdentifier(calleeNode.property)\n              ) {\n                localCallerName = calleeNode.property.name;\n              }\n\n              if (\n                !localCallerName ||\n                !intlayerCallerLocalNameMap.has(localCallerName)\n              )\n                return;\n\n              const callArguments = callExpressionPath.node.arguments;\n              if (callArguments.length === 0) return;\n\n              const firstArgument = callArguments[0];\n              let dictionaryKey: string | undefined;\n\n              if (babelTypes.isStringLiteral(firstArgument)) {\n                dictionaryKey = firstArgument.value;\n              } else if (\n                babelTypes.isTemplateLiteral(firstArgument) &&\n                firstArgument.expressions.length === 0 &&\n                firstArgument.quasis.length === 1 &&\n                firstArgument.quasis[0]\n              ) {\n                dictionaryKey =\n                  firstArgument.quasis[0].value.cooked ??\n                  firstArgument.quasis[0].value.raw;\n              }\n\n              if (!dictionaryKey) return;\n\n              const fieldRenameMap =\n                pruneContext.dictionaryKeyToFieldRenameMap.get(dictionaryKey);\n              if (!fieldRenameMap || fieldRenameMap.size === 0) return;\n\n              const parentNode = callExpressionPath.parent;\n\n              // ── Case 1: const { fieldA, fieldB } = useIntlayer('key') ────────\n              if (\n                babelTypes.isVariableDeclarator(parentNode) &&\n                babelTypes.isObjectPattern(parentNode.id)\n              ) {\n                for (const property of parentNode.id.properties) {\n                  if (!babelTypes.isObjectProperty(property)) continue;\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 renameEntry = fieldRenameMap.get(keyName);\n                  if (!renameEntry) continue;\n\n                  // { fieldA } → { shortA: fieldA }\n                  // { fieldA: localVar } → { shortA: localVar }\n                  if (property.shorthand) {\n                    property.shorthand = false;\n                    property.key = babelTypes.identifier(renameEntry.shortName);\n                  } else {\n                    property.key = babelTypes.identifier(renameEntry.shortName);\n                  }\n\n                  // Walk nested member accesses and secondary destructurings\n                  // on the local variable.\n                  if (\n                    renameEntry.children.size > 0 &&\n                    babelTypes.isIdentifier(property.value)\n                  ) {\n                    const localVarBinding = callExpressionPath.scope.getBinding(\n                      (property.value as BabelTypes.Identifier).name\n                    );\n                    if (localVarBinding) {\n                      for (const refPath of localVarBinding.referencePaths) {\n                        const { finalPath, finalRenameMap } = walkRenameChain(\n                          babelTypes,\n                          refPath,\n                          renameEntry.children\n                        );\n                        walkObjectDestructuring(\n                          babelTypes,\n                          finalPath,\n                          finalRenameMap\n                        );\n                      }\n                    }\n                  }\n                }\n                return;\n              }\n\n              // ── Case 2: useIntlayer('key').fieldA.nested ─────────────────────\n              if (\n                (babelTypes.isMemberExpression(parentNode) ||\n                  babelTypes.isOptionalMemberExpression(parentNode)) &&\n                (parentNode as BabelTypes.MemberExpression).object ===\n                  callExpressionPath.node\n              ) {\n                const { finalPath, finalRenameMap } = walkRenameChain(\n                  babelTypes,\n                  callExpressionPath,\n                  fieldRenameMap\n                );\n                walkObjectDestructuring(babelTypes, finalPath, finalRenameMap);\n                return;\n              }\n\n              // ── Case 3: const result = useIntlayer('key'); result.fieldA ─────\n              if (\n                babelTypes.isVariableDeclarator(parentNode) &&\n                babelTypes.isIdentifier(parentNode.id)\n              ) {\n                const variableName = parentNode.id.name;\n                const variableBinding =\n                  callExpressionPath.scope.getBinding(variableName);\n                if (!variableBinding) return;\n\n                for (const variableReferencePath of variableBinding.referencePaths) {\n                  // Direct access: result.fieldA or const { fieldA } = result\n                  const { finalPath, finalRenameMap } = walkRenameChain(\n                    babelTypes,\n                    variableReferencePath,\n                    fieldRenameMap\n                  );\n                  walkObjectDestructuring(\n                    babelTypes,\n                    finalPath,\n                    finalRenameMap\n                  );\n\n                  // Signal accessor: result().fieldA or const { fieldA } = result()\n                  // walkRenameChain stops at a CallExpression parent, so we need to\n                  // start a new walk from the call-expression node itself.\n                  const refParent = variableReferencePath.parent;\n                  if (\n                    (babelTypes.isCallExpression(refParent) ||\n                      babelTypes.isOptionalCallExpression(refParent)) &&\n                    (refParent as BabelTypes.CallExpression).callee ===\n                      variableReferencePath.node\n                  ) {\n                    const callPath = variableReferencePath.parentPath;\n                    if (callPath) {\n                      const {\n                        finalPath: signalFinalPath,\n                        finalRenameMap: signalFinalRenameMap,\n                      } = walkRenameChain(babelTypes, callPath, fieldRenameMap);\n                      walkObjectDestructuring(\n                        babelTypes,\n                        signalFinalPath,\n                        signalFinalRenameMap\n                      );\n                    }\n                  }\n                }\n              }\n            },\n          });\n        },\n      },\n    },\n  });\n"],"mappings":"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"}

package/dist/esm/babel-plugin-intlayer-optimize.mjs

@@ -1,6 +1,8 @@
+import { getNormalizedFilesListSet } from "./normalizedFilesList.mjs";
 import { dirname, join, relative } from "node:path";
-import { getPathHash } from "@intlayer/chokidar/utils";
+import { getPathHash } from "@intlayer/engine/utils";
 import { normalizePath } from "@intlayer/config/utils";
+import { getRewritableCallers } from "@intlayer/config/callers";
 
 //#region src/babel-plugin-intlayer-optimize.ts
 const PACKAGE_LIST = [
@@ -44,6 +46,11 @@ const STATIC_IMPORT_FUNCTION = {
 	useIntlayer: "useDictionary"
 };
 const DYNAMIC_IMPORT_FUNCTION = { useIntlayer: "useDictionaryDynamic" };
+/** Import rename table applied when the helper plan for a package is `dynamic`. */
+const DYNAMIC_HELPER_MAP = {
+	...STATIC_IMPORT_FUNCTION,
+	...DYNAMIC_IMPORT_FUNCTION
+};
 /**
 * Packages whose SSR-static `useDictionary` lives in a `/server` subpath
 * because it differs from the root one. Solid's reserves one hydration
@@ -75,6 +82,60 @@ const getKeyFromArgument = (arg, t) => {
 	if (arg && t.isTemplateLiteral(arg) && arg.expressions.length === 0 && arg.quasis.length === 1) return arg.quasis[0]?.value.cooked ?? arg.quasis[0]?.value.raw;
 };
 const isCallerName = (name) => CALLER_LIST.includes(name);
+/**
+* Splits a namespace string at the first `.` to separate the dictionary key
+* from an optional key prefix for nested namespaces, 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)
+	};
+};
+/**
+* Statically resolves the namespace of a compat caller call-site from its
+* descriptor's `namespaceSources` (argument / option / fixed — 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.
+*/
+const resolveCompatNamespaceMatch = (t, callArguments, descriptor) => {
+	for (const source of descriptor.namespaceSources) {
+		if (source.from === "fixed") return { fullNamespace: source.value };
+		if (source.from === "argument") {
+			const namespace = getKeyFromArgument(callArguments[source.index], t);
+			if (namespace !== void 0) return {
+				fullNamespace: namespace,
+				argumentIndex: source.index
+			};
+			continue;
+		}
+		if (source.from === "option") {
+			const optionsArgument = callArguments[source.argumentIndex];
+			if (!optionsArgument || !t.isObjectExpression(optionsArgument)) continue;
+			for (const property of optionsArgument.properties) {
+				if (!t.isObjectProperty(property)) continue;
+				if (!(t.isIdentifier(property.key) && property.key.name === source.property || t.isStringLiteral(property.key) && property.key.value === source.property)) continue;
+				const namespace = getKeyFromArgument(property.value, t);
+				if (namespace !== void 0) return {
+					fullNamespace: namespace,
+					optionProperty: property,
+					optionsObject: optionsArgument
+				};
+			}
+		}
+	}
+};
 const isDynamicPackage = (packageName) => PACKAGE_LIST_DYNAMIC.includes(packageName);
 /**
 * Decides, once per package import, which helper family applies to this file.
@@ -181,6 +242,7 @@ const intlayerOptimizeBabelPlugin = (babel) => {
 			this._newDynamicImports = /* @__PURE__ */ new Map();
 			this._callerMap = /* @__PURE__ */ new Map();
 			this._callerPackageMap = /* @__PURE__ */ new Map();
+			this._compatCallerMap = /* @__PURE__ */ new Map();
 			this._isIncluded = true;
 			this._hasValidImport = false;
 			this._isDictEntry = false;
@@ -190,7 +252,7 @@ const intlayerOptimizeBabelPlugin = (babel) => {
 			}
 			const filename = this.file.opts.filename ? normalizePath(this.file.opts.filename) : void 0;
 			if (this.opts.filesList && filename) {
-				if (!this.opts.filesList.map(normalizePath).includes(filename)) {
+				if (!getNormalizedFilesListSet(this.opts.filesList).has(filename)) {
 					this._isIncluded = false;
 					return;
 				}
@@ -223,24 +285,43 @@ const intlayerOptimizeBabelPlugin = (babel) => {
 			exit(programPath, state) {
 				if (state._isDictEntry) return;
 				if (!state._isIncluded) return;
+				const rewritableCompatCallers = getRewritableCallers(state.opts.compatCallers ?? []);
 				programPath.traverse({ ImportDeclaration(path) {
 					const src = path.node.source.value;
-					if (!PACKAGE_LIST.includes(src)) return;
+					const isNativePackage = PACKAGE_LIST.includes(src);
+					const compatCallersForSource = rewritableCompatCallers.filter((descriptor) => descriptor.importSources.includes(src));
+					if (!isNativePackage && compatCallersForSource.length === 0) return;
 					state._hasValidImport = true;
 					for (const spec of path.node.specifiers) {
 						if (!t.isImportSpecifier(spec)) continue;
 						const importedName = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
-						if (isCallerName(importedName)) {
+						if (isNativePackage && isCallerName(importedName)) {
 							state._callerMap?.set(spec.local.name, importedName);
 							state._callerPackageMap?.set(spec.local.name, src);
 						}
+						const compatDescriptor = compatCallersForSource.find((descriptor) => descriptor.callerName === importedName);
+						if (compatDescriptor) state._compatCallerMap?.set(spec.local.name, compatDescriptor);
 					}
 				} });
 				const packagesWithDynamicCall = /* @__PURE__ */ new Set();
 				const packagesWithFetchCall = /* @__PURE__ */ new Set();
+				let compatHasDynamicCall = false;
+				const unresolvableCompatLocalNames = /* @__PURE__ */ new Set();
 				programPath.traverse({ CallExpression(path) {
 					const callee = path.node.callee;
 					if (!t.isIdentifier(callee)) return;
+					const compatDescriptor = state._compatCallerMap?.get(callee.name);
+					if (compatDescriptor) {
+						const namespaceMatch = resolveCompatNamespaceMatch(t, path.node.arguments, compatDescriptor);
+						if (!namespaceMatch) {
+							unresolvableCompatLocalNames.add(callee.name);
+							return;
+						}
+						const { dictionaryKey } = splitNamespace(namespaceMatch.fullNamespace);
+						const compatOverrideMode = state.opts.dictionaryModeMap?.[dictionaryKey];
+						if (compatOverrideMode === "dynamic" || compatOverrideMode === "fetch") compatHasDynamicCall = true;
+						return;
+					}
 					if (state._callerMap?.get(callee.name) !== "useIntlayer") return;
 					const callerPackage = state._callerPackageMap?.get(callee.name);
 					if (!callerPackage) return;
@@ -250,17 +331,23 @@ const intlayerOptimizeBabelPlugin = (babel) => {
 					if (dictionaryOverrideMode === "dynamic") packagesWithDynamicCall.add(callerPackage);
 					else if (dictionaryOverrideMode === "fetch") packagesWithFetchCall.add(callerPackage);
 				} });
+				for (const localName of unresolvableCompatLocalNames) state._compatCallerMap?.delete(localName);
 				const getHelperPlan = (packageName) => resolveHelperPlan(packageName, state.opts.importMode, state.opts.isServer, packagesWithDynamicCall.has(packageName), packagesWithFetchCall.has(packageName));
+				const compatUseDynamicHelpers = state.opts.importMode === "dynamic" || state.opts.importMode === "fetch" || compatHasDynamicCall;
 				programPath.traverse({
 					ImportDeclaration(path) {
 						const src = path.node.source.value;
+						for (const spec of path.node.specifiers) {
+							if (!t.isImportSpecifier(spec)) continue;
+							const compatDescriptor = state._compatCallerMap?.get(spec.local.name);
+							if (!compatDescriptor) continue;
+							if (!compatDescriptor.importSources.includes(src)) continue;
+							spec.imported = t.identifier(compatUseDynamicHelpers ? compatDescriptor.dynamicReplacement : compatDescriptor.staticReplacement);
+						}
 						if (!PACKAGE_LIST.includes(src)) return;
 						const helperPlan = getHelperPlan(src);
 						const serverSource = helperPlan === "ssrStatic" ? SSR_STATIC_IMPORT_SOURCE[src] : void 0;
-						const helperMap = helperPlan === "dynamic" ? {
-							...STATIC_IMPORT_FUNCTION,
-							...DYNAMIC_IMPORT_FUNCTION
-						} : { ...STATIC_IMPORT_FUNCTION };
+						const helperMap = helperPlan === "dynamic" ? DYNAMIC_HELPER_MAP : STATIC_IMPORT_FUNCTION;
 						const serverSpecifiers = [];
 						for (const spec of path.node.specifiers) {
 							if (!t.isImportSpecifier(spec)) continue;
@@ -283,6 +370,49 @@ const intlayerOptimizeBabelPlugin = (babel) => {
 					CallExpression(path) {
 						const callee = path.node.callee;
 						if (!t.isIdentifier(callee)) return;
+						const compatDescriptor = state._compatCallerMap?.get(callee.name);
+						if (compatDescriptor) {
+							const callArguments = path.node.arguments;
+							const namespaceMatch = resolveCompatNamespaceMatch(t, callArguments, compatDescriptor);
+							if (!namespaceMatch) return;
+							state._hasValidImport = true;
+							const { dictionaryKey, keyPrefix } = splitNamespace(namespaceMatch.fullNamespace);
+							const compatOverrideMode = state.opts.dictionaryModeMap?.[dictionaryKey];
+							let compatCallMode = "static";
+							if (compatUseDynamicHelpers) if (compatOverrideMode === "dynamic" || compatOverrideMode === "fetch") compatCallMode = compatOverrideMode;
+							else if (state.opts.importMode === "dynamic" || state.opts.importMode === "fetch") compatCallMode = state.opts.importMode;
+							else compatCallMode = "dynamic";
+							let dictionaryIdent;
+							if (compatCallMode === "static") {
+								let staticIdent = state._newStaticImports?.get(dictionaryKey);
+								if (!staticIdent) {
+									staticIdent = makeIdent(dictionaryKey, t);
+									state._newStaticImports?.set(dictionaryKey, staticIdent);
+								}
+								dictionaryIdent = staticIdent;
+							} else {
+								let dynamicIdent = state._newDynamicImports?.get(dictionaryKey);
+								if (!dynamicIdent) {
+									const hash = getPathHash(dictionaryKey);
+									const suffix = compatCallMode === "fetch" ? "fetch" : "dyn";
+									dynamicIdent = t.identifier(`_${hash}_${suffix}`);
+									state._newDynamicImports?.set(dictionaryKey, dynamicIdent);
+								}
+								dictionaryIdent = dynamicIdent;
+							}
+							if (namespaceMatch.argumentIndex !== void 0) {
+								callArguments[namespaceMatch.argumentIndex] = t.identifier(dictionaryIdent.name);
+								const insertAt = namespaceMatch.argumentIndex + 1;
+								const insertedArguments = [];
+								if (compatCallMode !== "static") insertedArguments.push(t.stringLiteral(dictionaryKey));
+								if (keyPrefix) insertedArguments.push(t.stringLiteral(keyPrefix));
+								callArguments.splice(insertAt, 0, ...insertedArguments);
+							} else if (compatCallMode !== "static") callArguments.unshift(t.identifier(dictionaryIdent.name), t.stringLiteral(dictionaryKey));
+							else callArguments.unshift(t.identifier(dictionaryIdent.name));
+							if (namespaceMatch.optionProperty && namespaceMatch.optionsObject) if (keyPrefix) namespaceMatch.optionProperty.value = t.stringLiteral(keyPrefix);
+							else namespaceMatch.optionsObject.properties = namespaceMatch.optionsObject.properties.filter((property) => property !== namespaceMatch.optionProperty);
+							return;
+						}
 						const originalImportedName = state._callerMap?.get(callee.name);
 						if (!originalImportedName) return;
 						state._hasValidImport = true;

package/dist/esm/babel-plugin-intlayer-optimize.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-optimize.mjs","names":[],"sources":["../../src/babel-plugin-intlayer-optimize.ts"],"sourcesContent":["import { dirname, join, relative } from 'node:path';\nimport type { NodePath, PluginObject, PluginPass } from '@babel/core';\nimport type * as BabelTypes from '@babel/types';\nimport { getPathHash } from '@intlayer/chokidar/utils';\nimport { normalizePath } from '@intlayer/config/utils';\n\nconst PACKAGE_LIST = [\n  'intlayer',\n  '@intlayer/core',\n  'react-intlayer',\n  'react-intlayer/client',\n  'react-intlayer/server',\n  'next-intlayer',\n  'next-intlayer/client',\n  'next-intlayer/server',\n  'svelte-intlayer',\n  'vue-intlayer',\n  'angular-intlayer',\n  'preact-intlayer',\n  'solid-intlayer',\n  'lit-intlayer',\n  'vanilla-intlayer',\n];\n\nconst CALLER_LIST = ['useIntlayer', 'getIntlayer'] as const;\n\n/**\n * Packages that support dynamic import\n */\nconst PACKAGE_LIST_DYNAMIC = [\n  'react-intlayer',\n  'react-intlayer/client',\n  'react-intlayer/server',\n  'next-intlayer',\n  'next-intlayer/client',\n  'next-intlayer/server',\n  'preact-intlayer',\n  'vue-intlayer',\n  'solid-intlayer',\n  'svelte-intlayer',\n  'angular-intlayer',\n  'lit-intlayer',\n  'vanilla-intlayer',\n] as const;\n\nconst STATIC_IMPORT_FUNCTION = {\n  getIntlayer: 'getDictionary',\n  useIntlayer: 'useDictionary',\n} as const;\n\nconst DYNAMIC_IMPORT_FUNCTION = {\n  useIntlayer: 'useDictionaryDynamic',\n} as const;\n\n/**\n * Packages whose SSR-static `useDictionary` lives in a `/server` subpath\n * because it differs from the root one. Solid's reserves one hydration\n * resource slot so hydration ids stay aligned with the client's\n * `useDictionaryDynamic`; for other frameworks the root `useDictionary` is\n * already the correct SSR-static implementation.\n */\nconst SSR_STATIC_IMPORT_SOURCE: Partial<Record<string, string>> = {\n  'solid-intlayer': 'solid-intlayer/server',\n};\n\ntype CallerName = (typeof CALLER_LIST)[number];\ntype ImportMode = 'static' | 'dynamic' | 'fetch';\n\n/**\n * Options for the optimization Babel plugin\n */\nexport type OptimizePluginOptions = {\n  /**\n   * If false, the plugin will not apply any transformation.\n   */\n  optimize?: boolean;\n  /**\n   * The path to the dictionaries directory.\n   */\n  dictionariesDir: string;\n  /**\n   * The path to the dictionaries entry file.\n   */\n  dictionariesEntryPath: string;\n  /**\n   * The path to the unmerged dictionaries entry file.\n   */\n  unmergedDictionariesEntryPath: string;\n  /**\n   * The path to the unmerged dictionaries directory.\n   */\n  unmergedDictionariesDir: string;\n  /**\n   * The path to the dictionaries directory.\n   */\n  dynamicDictionariesDir: string;\n  /**\n   * The path to the dynamic dictionaries entry file.\n   */\n  dynamicDictionariesEntryPath: string;\n  /**\n   * The path to the fetch dictionaries directory.\n   */\n  fetchDictionariesDir: string;\n  /**\n   * The path to the fetch dictionaries entry file.\n   */\n  fetchDictionariesEntryPath: string;\n  /**\n   * If true, the plugin will replace the dictionary entry file with `export default {}`.\n   */\n  replaceDictionaryEntry: boolean;\n  /**\n   * If true, the plugin will activate the dynamic import of the dictionaries. It will rely on Suspense to load the dictionaries.\n   */\n  importMode: 'static' | 'dynamic' | 'fetch' | undefined;\n  /**\n   * Map of dictionary keys to their specific import mode.\n   */\n  dictionaryModeMap?: Record<\n    string,\n    'static' | 'dynamic' | 'fetch' | undefined\n  >;\n  /**\n   * Files list to traverse.\n   */\n  filesList: string[];\n  /**\n   * Whether the current transform is for an SSR bundle.\n   */\n  isServer?: boolean;\n};\n\ntype State = PluginPass & {\n  opts: OptimizePluginOptions;\n  /** map key → generated ident (per-file) for static imports */\n  _newStaticImports?: Map<string, BabelTypes.Identifier>;\n  /** map key → generated ident (per-file) for dynamic imports */\n  _newDynamicImports?: Map<string, BabelTypes.Identifier>;\n  /** whether the current file imported *any* intlayer package */\n  _hasValidImport?: boolean;\n  /** map from local identifier name to the imported intlayer func name ('useIntlayer' | 'getIntlayer') */\n  _callerMap?: Map<string, (typeof CALLER_LIST)[number]>;\n  /** map from local identifier name to the intlayer package it was imported from */\n  _callerPackageMap?: Map<string, string>;\n  /** whether the current file *is* the dictionaries entry file */\n  _isDictEntry?: boolean;\n  /** whether the current file is included in the filesList */\n  _isIncluded?: boolean;\n};\n\n/**\n * Replicates the xxHash64 → Base-62 algorithm used by the SWC version\n * and prefixes an underscore so the generated identifiers never collide\n * with user-defined ones.\n */\nconst makeIdent = (\n  key: string,\n  t: typeof BabelTypes\n): BabelTypes.Identifier => {\n  const hash = getPathHash(key);\n  return t.identifier(`_${hash}`);\n};\n\nconst computeImport = (\n  fromFile: string,\n  dictionariesDir: string,\n  dynamicDictionariesDir: string,\n  fetchDictionariesDir: string,\n  key: string,\n  importMode: 'static' | 'dynamic' | 'fetch'\n): string => {\n  let relativePath = join(dictionariesDir, `${key}.json`);\n\n  if (importMode === 'fetch') {\n    relativePath = join(fetchDictionariesDir, `${key}.mjs`);\n  }\n\n  if (importMode === 'dynamic') {\n    relativePath = join(dynamicDictionariesDir, `${key}.mjs`);\n  }\n\n  let rel = relative(dirname(fromFile), relativePath);\n\n  // Fix windows path\n  rel = normalizePath(rel);\n\n  // Fix relative path\n  if (!rel.startsWith('./') && !rel.startsWith('../')) {\n    rel = `./${rel}`;\n  }\n\n  return rel;\n};\n\nconst getKeyFromArgument = (\n  arg: BabelTypes.Node | null | undefined,\n  t: typeof BabelTypes\n): string | undefined => {\n  if (arg && t.isStringLiteral(arg)) {\n    return arg.value;\n  }\n\n  if (\n    arg &&\n    t.isTemplateLiteral(arg) &&\n    arg.expressions.length === 0 &&\n    arg.quasis.length === 1\n  ) {\n    return arg.quasis[0]?.value.cooked ?? arg.quasis[0]?.value.raw;\n  }\n\n  return undefined;\n};\n\nconst isCallerName = (name: string): name is CallerName =>\n  CALLER_LIST.includes(name as CallerName);\n\nconst isDynamicPackage = (\n  packageName: string\n): packageName is (typeof PACKAGE_LIST_DYNAMIC)[number] =>\n  PACKAGE_LIST_DYNAMIC.includes(\n    packageName as (typeof PACKAGE_LIST_DYNAMIC)[number]\n  );\n\n/**\n * Helper family every `useIntlayer`/`getIntlayer` call from one package import\n * resolves to in the current file. `ssrStatic` is the SSR bundle of a\n * dynamic-mode file: rewritten to the static `useDictionary` (from the\n * package's `/server` entry when it has one — see\n * `SSR_STATIC_IMPORT_SOURCE`) so the server renders static JSON while the\n * client keeps the dynamic loader.\n */\ntype PackageHelperPlan = 'static' | 'dynamic' | 'ssrStatic';\n\n/**\n * Decides, once per package import, which helper family applies to this file.\n * The import rewrite and the per-call rewrite must both derive from this\n * single decision, or the emitted helper and its argument shape diverge.\n *\n * Fetch wins over `ssrStatic`: fetch dictionaries are runtime content, so the\n * server must keep the real fetch path instead of rendering build-time JSON.\n */\nconst resolveHelperPlan = (\n  packageName: string,\n  importMode: ImportMode | undefined,\n  isServer: boolean | undefined,\n  packageHasDynamicCall: boolean,\n  packageHasFetchCall: boolean\n): PackageHelperPlan => {\n  if (!isDynamicPackage(packageName)) return 'static';\n\n  if (importMode === 'fetch' || packageHasFetchCall) return 'dynamic';\n\n  if (importMode === 'dynamic' || packageHasDynamicCall) {\n    return isServer === true ? 'ssrStatic' : 'dynamic';\n  }\n\n  return 'static';\n};\n\n/**\n * Babel plugin that transforms Intlayer function calls and auto-imports dictionaries.\n *\n * This plugin transforms calls to `useIntlayer()` and `getIntlayer()` from various Intlayer\n * packages into optimized dictionary access patterns, automatically importing the required\n * dictionary files based on the configured import mode.\n *\n * ## Supported Input Patterns\n *\n * The plugin recognizes these function calls:\n *\n * ```ts\n * // useIntlayer\n * import { useIntlayer } from 'react-intlayer';\n * import { useIntlayer } from 'next-intlayer';\n *\n * // getIntlayer\n * import { getIntlayer } from 'intlayer';\n *\n * // Usage\n * const content = useIntlayer('app');\n * const content = getIntlayer('app');\n * ```\n *\n * ## Transformation Modes\n *\n * ### Static Mode (default: `importMode = \"static\"`)\n *\n * Imports JSON dictionaries directly and replaces function calls with dictionary access:\n *\n * **Output:**\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import { useDictionary as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash);\n * const content2 = getIntlayer(_dicHash);\n * ```\n *\n * ### Dynamic Mode (`importMode = \"dynamic\"`)\n *\n * Uses dynamic dictionary loading with Suspense support:\n *\n * **Output:**\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import _dicHash_dyn from '../../.intlayer/dynamic_dictionaries/app.mjs';\n * import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash_dyn, 'app');\n * const content2 = getIntlayer(_dicHash);\n * ```\n *\n * ### Fetch Mode (`importMode = \"fetch\"`)\n *\n * Uses fetch-based dictionary loading for remote dictionaries:\n *\n * **Output if `dictionaryModeMap` includes the key with \"fetch\" value:**\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import _dicHash_fetch from '../../.intlayer/fetch_dictionaries/app.mjs';\n * import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash_fetch, \"app\");\n * const content2 = getIntlayer(_dicHash);\n * ```\n *\n * > If `dictionaryModeMap` does not include the key with \"fetch\" value, the plugin will fallback to the dynamic import mode.\n *\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import _dicHash_dyn from '../../.intlayer/dynamic_dictionaries/app.mjs';\n * import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash_dyn, 'app');\n * const content2 = getIntlayer(_dicHash);\n * ```\n */\nexport const intlayerOptimizeBabelPlugin = (babel: {\n  types: typeof BabelTypes;\n}): PluginObject<State> => {\n  const { types: t } = babel;\n\n  return {\n    name: 'babel-plugin-intlayer-transform',\n\n    pre() {\n      this._newStaticImports = new Map();\n      this._newDynamicImports = new Map();\n      this._callerMap = new Map();\n      this._callerPackageMap = new Map();\n      this._isIncluded = true;\n      this._hasValidImport = false;\n      this._isDictEntry = false;\n\n      // If optimize is false, skip processing entirely\n      if (this.opts.optimize === false) {\n        this._isIncluded = false;\n        return;\n      }\n\n      // If filesList is provided, check if current file is included\n      const filename = this.file.opts.filename\n        ? normalizePath(this.file.opts.filename)\n        : undefined;\n      if (this.opts.filesList && filename) {\n        const filesList = this.opts.filesList.map(normalizePath);\n        const isIncluded = filesList.includes(filename);\n\n        if (!isIncluded) {\n          // Force _isIncluded to false to skip processing\n          this._isIncluded = false;\n          return;\n        }\n      }\n    },\n\n    visitor: {\n      /* If this file *is* the dictionaries entry, short-circuit: export {} */\n      Program: {\n        enter(programPath, state) {\n          // Safe access to filename\n          const filename = state.file.opts.filename\n            ? normalizePath(state.file.opts.filename)\n            : undefined;\n          const dictionariesEntryPath = state.opts.dictionariesEntryPath\n            ? normalizePath(state.opts.dictionariesEntryPath)\n            : undefined;\n\n          // Check if this is the correct file to transform\n\n          if (\n            state.opts.replaceDictionaryEntry &&\n            filename === dictionariesEntryPath\n          ) {\n            state._isDictEntry = true;\n\n            // Traverse the program to surgically remove/edit specific parts\n            programPath.traverse({\n              // Remove all import statements (cleaning up 'sssss.json')\n              ImportDeclaration(path) {\n                path.remove();\n              },\n\n              // Find the variable definition and empty the object\n              VariableDeclarator(path) {\n                // We look for: const x = { ... }\n\n                if (t.isObjectExpression(path.node.init)) {\n                  // Set the object properties to an empty array: {}\n                  path.node.init.properties = [];\n                }\n              },\n            });\n\n            // (Optional) Stop other plugins from processing this file further if needed\n            // programPath.stop();\n          }\n        },\n\n        /**\n         * After full traversal, process imports and call expressions, then inject the JSON dictionary imports.\n         *\n         * We do the transformation in Program.exit (via a manual traverse) rather than using\n         * top-level ImportDeclaration/CallExpression visitors. This ensures that if another plugin\n         * (like babel-plugin-intlayer-extract) adds new useIntlayer calls in its Program.exit,\n         * we will see and transform them here because our Program.exit runs after theirs.\n         */\n        exit(programPath, state) {\n          if (state._isDictEntry) return; // nothing else to do – already replaced\n\n          if (!state._isIncluded) return; // early-out if file is not included\n\n          // Manual traversal to process imports and call expressions\n          // This runs AFTER all other plugins' visitors have completed\n          programPath.traverse({\n            /* Inspect every intlayer import before deciding helper rewrites. */\n            ImportDeclaration(path) {\n              const src = path.node.source.value;\n\n              if (!PACKAGE_LIST.includes(src)) return;\n\n              state._hasValidImport = true;\n\n              for (const spec of path.node.specifiers) {\n                if (!t.isImportSpecifier(spec)) continue;\n\n                const importedName = t.isIdentifier(spec.imported)\n                  ? spec.imported.name\n                  : (spec.imported as BabelTypes.StringLiteral).value;\n\n                if (isCallerName(importedName)) {\n                  state._callerMap?.set(spec.local.name, importedName);\n                  state._callerPackageMap?.set(spec.local.name, src);\n                }\n              }\n            },\n          });\n\n          // Pre-pass to determine if dictionary-level overrides require the\n          // dynamic helper in an otherwise static file.\n          const packagesWithDynamicCall = new Set<string>();\n          const packagesWithFetchCall = new Set<string>();\n          programPath.traverse({\n            CallExpression(path) {\n              const callee = path.node.callee;\n\n              if (!t.isIdentifier(callee)) return;\n\n              const originalImportedName = state._callerMap?.get(callee.name);\n              if (originalImportedName !== 'useIntlayer') return;\n\n              const callerPackage = state._callerPackageMap?.get(callee.name);\n              if (!callerPackage) return;\n\n              const key = getKeyFromArgument(path.node.arguments[0], t);\n              if (!key) return;\n\n              const dictionaryOverrideMode =\n                state.opts.dictionaryModeMap?.[key];\n\n              if (dictionaryOverrideMode === 'dynamic') {\n                packagesWithDynamicCall.add(callerPackage);\n              } else if (dictionaryOverrideMode === 'fetch') {\n                packagesWithFetchCall.add(callerPackage);\n              }\n            },\n          });\n\n          const getHelperPlan = (packageName: string): PackageHelperPlan =>\n            resolveHelperPlan(\n              packageName,\n              state.opts.importMode,\n              state.opts.isServer,\n              packagesWithDynamicCall.has(packageName),\n              packagesWithFetchCall.has(packageName)\n            );\n\n          programPath.traverse({\n            ImportDeclaration(path) {\n              const src = path.node.source.value;\n\n              if (!PACKAGE_LIST.includes(src)) return;\n\n              // Per-import swap, mirrored across bundles — Solid hydration\n              // ids rely on the SSR and client helpers consuming one\n              // resource slot per call alike (see solid-intlayer/server).\n              const helperPlan = getHelperPlan(src);\n              const serverSource =\n                helperPlan === 'ssrStatic'\n                  ? SSR_STATIC_IMPORT_SOURCE[src]\n                  : undefined;\n\n              const helperMap: Record<string, string> =\n                helperPlan === 'dynamic'\n                  ? { ...STATIC_IMPORT_FUNCTION, ...DYNAMIC_IMPORT_FUNCTION }\n                  : { ...STATIC_IMPORT_FUNCTION };\n\n              const serverSpecifiers: BabelTypes.ImportSpecifier[] = [];\n\n              for (const spec of path.node.specifiers) {\n                if (!t.isImportSpecifier(spec)) continue;\n\n                const importedName = t.isIdentifier(spec.imported)\n                  ? spec.imported.name\n                  : (spec.imported as BabelTypes.StringLiteral).value;\n\n                if (!isCallerName(importedName)) continue;\n\n                if (serverSource && importedName === 'useIntlayer') {\n                  spec.imported = t.identifier('useDictionary');\n                  serverSpecifiers.push(spec);\n                  continue;\n                }\n\n                const newIdentifier = helperMap[importedName];\n\n                if (newIdentifier) {\n                  // Keep the local alias intact (so calls remain `useIntlayer` /\n                  // `getIntlayer`), but rewrite the imported identifier so it\n                  // points to our helper implementation.\n                  spec.imported = t.identifier(newIdentifier);\n                }\n              }\n\n              if (serverSpecifiers.length > 0 && serverSource) {\n                // Move the helper to the /server entry, keeping any other\n                // specifiers (useLocale, …) on the original import.\n                path.insertAfter(\n                  t.importDeclaration(\n                    serverSpecifiers,\n                    t.stringLiteral(serverSource)\n                  )\n                );\n                path.node.specifiers = path.node.specifiers.filter(\n                  (spec) =>\n                    !serverSpecifiers.includes(\n                      spec as BabelTypes.ImportSpecifier\n                    )\n                );\n                if (path.node.specifiers.length === 0) {\n                  path.remove();\n                }\n              }\n            },\n\n            /* Replace calls: useIntlayer(\"foo\") → useDictionary(_hash) or useDictionaryDynamic(_hash, \"foo\") */\n            CallExpression(path) {\n              const callee = path.node.callee;\n\n              if (!t.isIdentifier(callee)) return;\n\n              const originalImportedName = state._callerMap?.get(callee.name);\n              if (!originalImportedName) return;\n\n              // Ensure we ultimately emit helper imports for files that *invoke*\n              // the hooks, even if they didn't import them directly (edge cases with\n              // re-exports).\n              state._hasValidImport = true;\n\n              const key = getKeyFromArgument(path.node.arguments[0], t);\n              if (!key) return;\n\n              const callerPackage = state._callerPackageMap?.get(callee.name);\n              const importMode = state.opts.importMode;\n              const isUseIntlayer = originalImportedName === 'useIntlayer';\n              const dictionaryOverrideMode =\n                state.opts.dictionaryModeMap?.[key];\n              const helperPlan =\n                callerPackage === undefined\n                  ? 'static'\n                  : getHelperPlan(callerPackage);\n\n              // Decide per-call mode: 'static' | 'dynamic' | 'fetch'.\n              let perCallMode: ImportMode = 'static';\n\n              if (isUseIntlayer && helperPlan === 'dynamic') {\n                if (dictionaryOverrideMode) {\n                  perCallMode = dictionaryOverrideMode;\n                } else if (importMode === 'dynamic' || importMode === 'fetch') {\n                  perCallMode = importMode;\n                }\n              } else if (isUseIntlayer && helperPlan === 'static') {\n                // The global mode is static, but a per-dictionary override can\n                // still force dynamic/fetch for this specific call.\n                if (\n                  dictionaryOverrideMode === 'dynamic' ||\n                  dictionaryOverrideMode === 'fetch'\n                ) {\n                  perCallMode = dictionaryOverrideMode;\n                }\n              }\n\n              let ident: BabelTypes.Identifier;\n\n              if (perCallMode === 'fetch') {\n                // Use fetch dictionaries entry for selected keys\n                let dynamicIdent = state._newDynamicImports?.get(key);\n\n                if (!dynamicIdent) {\n                  const hash = getPathHash(key);\n                  dynamicIdent = t.identifier(`_${hash}_fetch`);\n                  state._newDynamicImports?.set(key, dynamicIdent);\n                }\n                ident = dynamicIdent;\n\n                // Helper: first argument is the dictionary entry, second is the key\n                path.node.arguments = [\n                  t.identifier(ident.name),\n                  ...path.node.arguments,\n                ];\n              } else if (perCallMode === 'dynamic') {\n                // Use dynamic dictionaries entry\n                let dynamicIdent = state._newDynamicImports?.get(key);\n\n                if (!dynamicIdent) {\n                  // Create a unique identifier for dynamic imports by appending a suffix\n                  const hash = getPathHash(key);\n                  dynamicIdent = t.identifier(`_${hash}_dyn`);\n                  state._newDynamicImports?.set(key, dynamicIdent);\n                }\n                ident = dynamicIdent;\n\n                // Dynamic helper: first argument is the dictionary, second is the key.\n                path.node.arguments = [\n                  t.identifier(ident.name),\n                  ...path.node.arguments,\n                ];\n              } else {\n                // Use static imports for getIntlayer or useIntlayer when not using dynamic helpers\n                let staticIdent = state._newStaticImports?.get(key);\n\n                if (!staticIdent) {\n                  staticIdent = makeIdent(key, t);\n                  state._newStaticImports?.set(key, staticIdent);\n                }\n                ident = staticIdent;\n\n                // Static helper (useDictionary / getDictionary): replace key with ident.\n                // After the splice above the key is always at index 0.\n                path.node.arguments[0] = t.identifier(ident.name);\n              }\n            },\n          });\n\n          // Early-out if we touched nothing\n\n          if (!state._hasValidImport) return;\n\n          const file = state.file.opts.filename!;\n          const dictionariesDir = state.opts.dictionariesDir;\n          const dynamicDictionariesDir = state.opts.dynamicDictionariesDir;\n          const fetchDictionariesDir = state.opts.fetchDictionariesDir;\n          const imports: BabelTypes.ImportDeclaration[] = [];\n\n          // Generate static JSON imports (getIntlayer always uses JSON dictionaries)\n          for (const [key, ident] of state._newStaticImports!) {\n            const rel = computeImport(\n              file,\n              dictionariesDir,\n              dynamicDictionariesDir,\n              fetchDictionariesDir,\n              key,\n              'static'\n            );\n\n            const importDeclarationNode = t.importDeclaration(\n              [t.importDefaultSpecifier(t.identifier(ident.name))],\n              t.stringLiteral(rel)\n            );\n\n            // Add 'type: json' attribute for JSON files\n            importDeclarationNode.attributes = [\n              t.importAttribute(t.identifier('type'), t.stringLiteral('json')),\n            ];\n\n            imports.push(importDeclarationNode);\n          }\n\n          // Generate dynamic/fetch imports (for useIntlayer when using dynamic/fetch helpers)\n          for (const [key, ident] of state._newDynamicImports!) {\n            const modeForThisIdent: 'dynamic' | 'fetch' = ident.name.endsWith(\n              '_fetch'\n            )\n              ? 'fetch'\n              : 'dynamic';\n\n            const rel = computeImport(\n              file,\n              dictionariesDir,\n              dynamicDictionariesDir,\n              fetchDictionariesDir,\n              key,\n              modeForThisIdent\n            );\n            imports.push(\n              t.importDeclaration(\n                [t.importDefaultSpecifier(t.identifier(ident.name))],\n                t.stringLiteral(rel)\n              )\n            );\n          }\n\n          if (!imports.length) return;\n\n          /* Keep \"use client\" / \"use server\" directives at the very top. */\n          const bodyPaths = programPath.get(\n            'body'\n          ) as NodePath<BabelTypes.Statement>[];\n          let insertPos = 0;\n          for (const stmtPath of bodyPaths) {\n            const stmt = stmtPath.node;\n\n            if (\n              t.isExpressionStatement(stmt) &&\n              t.isStringLiteral(stmt.expression) &&\n              !stmt.expression.value.startsWith('import') &&\n              !stmt.expression.value.startsWith('require')\n            ) {\n              insertPos += 1;\n            } else {\n              break;\n            }\n          }\n\n          programPath.node.body.splice(insertPos, 0, ...imports);\n        },\n      },\n    },\n  };\n};\n"],"mappings":"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"}
+{"version":3,"file":"babel-plugin-intlayer-optimize.mjs","names":[],"sources":["../../src/babel-plugin-intlayer-optimize.ts"],"sourcesContent":["import { dirname, join, relative } from 'node:path';\nimport type { NodePath, PluginObject, PluginPass } from '@babel/core';\nimport type * as BabelTypes from '@babel/types';\nimport {\n  type CallerDescriptor,\n  getRewritableCallers,\n} from '@intlayer/config/callers';\nimport { normalizePath } from '@intlayer/config/utils';\nimport { getPathHash } from '@intlayer/engine/utils';\nimport { getNormalizedFilesListSet } from './normalizedFilesList';\n\nconst PACKAGE_LIST = [\n  'intlayer',\n  '@intlayer/core',\n  'react-intlayer',\n  'react-intlayer/client',\n  'react-intlayer/server',\n  'next-intlayer',\n  'next-intlayer/client',\n  'next-intlayer/server',\n  'svelte-intlayer',\n  'vue-intlayer',\n  'angular-intlayer',\n  'preact-intlayer',\n  'solid-intlayer',\n  'lit-intlayer',\n  'vanilla-intlayer',\n];\n\nconst CALLER_LIST = ['useIntlayer', 'getIntlayer'] as const;\n\n/**\n * Packages that support dynamic import\n */\nconst PACKAGE_LIST_DYNAMIC = [\n  'react-intlayer',\n  'react-intlayer/client',\n  'react-intlayer/server',\n  'next-intlayer',\n  'next-intlayer/client',\n  'next-intlayer/server',\n  'preact-intlayer',\n  'vue-intlayer',\n  'solid-intlayer',\n  'svelte-intlayer',\n  'angular-intlayer',\n  'lit-intlayer',\n  'vanilla-intlayer',\n] as const;\n\nconst STATIC_IMPORT_FUNCTION = {\n  getIntlayer: 'getDictionary',\n  useIntlayer: 'useDictionary',\n} as const;\n\nconst DYNAMIC_IMPORT_FUNCTION = {\n  useIntlayer: 'useDictionaryDynamic',\n} as const;\n\n/** Import rename table applied when the helper plan for a package is `dynamic`. */\nconst DYNAMIC_HELPER_MAP: Record<string, string> = {\n  ...STATIC_IMPORT_FUNCTION,\n  ...DYNAMIC_IMPORT_FUNCTION,\n};\n\n/**\n * Packages whose SSR-static `useDictionary` lives in a `/server` subpath\n * because it differs from the root one. Solid's reserves one hydration\n * resource slot so hydration ids stay aligned with the client's\n * `useDictionaryDynamic`; for other frameworks the root `useDictionary` is\n * already the correct SSR-static implementation.\n */\nconst SSR_STATIC_IMPORT_SOURCE: Partial<Record<string, string>> = {\n  'solid-intlayer': 'solid-intlayer/server',\n};\n\ntype CallerName = (typeof CALLER_LIST)[number];\ntype ImportMode = 'static' | 'dynamic' | 'fetch';\n\n/**\n * Options for the optimization Babel plugin\n */\nexport type OptimizePluginOptions = {\n  /**\n   * If false, the plugin will not apply any transformation.\n   */\n  optimize?: boolean;\n  /**\n   * The path to the dictionaries directory.\n   */\n  dictionariesDir: string;\n  /**\n   * The path to the dictionaries entry file.\n   */\n  dictionariesEntryPath: string;\n  /**\n   * The path to the unmerged dictionaries entry file.\n   */\n  unmergedDictionariesEntryPath: string;\n  /**\n   * The path to the unmerged dictionaries directory.\n   */\n  unmergedDictionariesDir: string;\n  /**\n   * The path to the dictionaries directory.\n   */\n  dynamicDictionariesDir: string;\n  /**\n   * The path to the dynamic dictionaries entry file.\n   */\n  dynamicDictionariesEntryPath: string;\n  /**\n   * The path to the fetch dictionaries directory.\n   */\n  fetchDictionariesDir: string;\n  /**\n   * The path to the fetch dictionaries entry file.\n   */\n  fetchDictionariesEntryPath: string;\n  /**\n   * If true, the plugin will replace the dictionary entry file with `export default {}`.\n   */\n  replaceDictionaryEntry: boolean;\n  /**\n   * If true, the plugin will activate the dynamic import of the dictionaries. It will rely on Suspense to load the dictionaries.\n   */\n  importMode: 'static' | 'dynamic' | 'fetch' | undefined;\n  /**\n   * Map of dictionary keys to their specific import mode.\n   */\n  dictionaryModeMap?: Record<\n    string,\n    'static' | 'dynamic' | 'fetch' | undefined\n  >;\n  /**\n   * Files list to traverse.\n   */\n  filesList: string[];\n  /**\n   * Whether the current transform is for an SSR bundle.\n   */\n  isServer?: boolean;\n  /**\n   * Compat-adapter caller descriptors injected by the compat packages'\n   * bundler plugins (e.g. `@intlayer/react-i18next/plugin`).\n   *\n   * Callers carrying `staticReplacement` / `dynamicReplacement` are rewritten\n   * the same way as native `useIntlayer` calls: the namespace string argument\n   * is replaced by a pre-imported dictionary object and the import specifier\n   * is re-pointed to the dictionary-accepting variant, e.g.\n   * `useTranslation('about')` → `useDictionary(_dictHash)`.\n   *\n   * No compat-specific name is hard-coded in this plugin — the whole rewrite\n   * is driven by these descriptors.\n   */\n  compatCallers?: CallerDescriptor[];\n};\n\ntype State = PluginPass & {\n  opts: OptimizePluginOptions;\n  /** map key → generated ident (per-file) for static imports */\n  _newStaticImports?: Map<string, BabelTypes.Identifier>;\n  /** map key → generated ident (per-file) for dynamic imports */\n  _newDynamicImports?: Map<string, BabelTypes.Identifier>;\n  /** whether the current file imported *any* intlayer package */\n  _hasValidImport?: boolean;\n  /** map from local identifier name to the imported intlayer func name ('useIntlayer' | 'getIntlayer') */\n  _callerMap?: Map<string, (typeof CALLER_LIST)[number]>;\n  /** map from local identifier name to the intlayer package it was imported from */\n  _callerPackageMap?: Map<string, string>;\n  /** map from local identifier name to the compat caller descriptor it was imported as */\n  _compatCallerMap?: Map<string, CallerDescriptor>;\n  /** whether the current file *is* the dictionaries entry file */\n  _isDictEntry?: boolean;\n  /** whether the current file is included in the filesList */\n  _isIncluded?: boolean;\n};\n\n/**\n * Replicates the xxHash64 → Base-62 algorithm used by the SWC version\n * and prefixes an underscore so the generated identifiers never collide\n * with user-defined ones.\n */\nconst makeIdent = (\n  key: string,\n  t: typeof BabelTypes\n): BabelTypes.Identifier => {\n  const hash = getPathHash(key);\n  return t.identifier(`_${hash}`);\n};\n\nconst computeImport = (\n  fromFile: string,\n  dictionariesDir: string,\n  dynamicDictionariesDir: string,\n  fetchDictionariesDir: string,\n  key: string,\n  importMode: 'static' | 'dynamic' | 'fetch'\n): string => {\n  let relativePath = join(dictionariesDir, `${key}.json`);\n\n  if (importMode === 'fetch') {\n    relativePath = join(fetchDictionariesDir, `${key}.mjs`);\n  }\n\n  if (importMode === 'dynamic') {\n    relativePath = join(dynamicDictionariesDir, `${key}.mjs`);\n  }\n\n  let rel = relative(dirname(fromFile), relativePath);\n\n  // Fix windows path\n  rel = normalizePath(rel);\n\n  // Fix relative path\n  if (!rel.startsWith('./') && !rel.startsWith('../')) {\n    rel = `./${rel}`;\n  }\n\n  return rel;\n};\n\nconst getKeyFromArgument = (\n  arg: BabelTypes.Node | null | undefined,\n  t: typeof BabelTypes\n): string | undefined => {\n  if (arg && t.isStringLiteral(arg)) {\n    return arg.value;\n  }\n\n  if (\n    arg &&\n    t.isTemplateLiteral(arg) &&\n    arg.expressions.length === 0 &&\n    arg.quasis.length === 1\n  ) {\n    return arg.quasis[0]?.value.cooked ?? arg.quasis[0]?.value.raw;\n  }\n\n  return undefined;\n};\n\nconst isCallerName = (name: string): name is CallerName =>\n  CALLER_LIST.includes(name as CallerName);\n\n/**\n * Splits a namespace string at the first `.` to separate the dictionary key\n * from an optional key prefix for nested namespaces, mirroring the SWC\n * plugin's `split_namespace`.\n *\n *   `'about'`         → `{ dictionaryKey: 'about', keyPrefix: '' }`\n *   `'about.counter'` → `{ dictionaryKey: 'about', keyPrefix: 'counter' }`\n */\nconst 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 * Result of statically resolving the namespace of a compat caller call-site.\n */\ntype CompatNamespaceMatch = {\n  /** The full namespace string, e.g. `'about.counter'`. */\n  fullNamespace: string;\n  /** Index of the positional namespace argument, when read from an argument. */\n  argumentIndex?: number;\n  /**\n   * The options-object property holding the namespace, when read from an\n   * option. The rewrite mutates it in place (key-prefix remainder) or removes\n   * it from `optionsObject`.\n   */\n  optionProperty?: BabelTypes.ObjectProperty;\n  /** The options object owning `optionProperty`. */\n  optionsObject?: BabelTypes.ObjectExpression;\n};\n\n/**\n * Statically resolves the namespace of a compat caller call-site from its\n * descriptor's `namespaceSources` (argument / option / fixed — the\n * per-message-id `path-first-segment` form cannot bind one dictionary to the\n * call site and is skipped). Returns `undefined` when the namespace is absent\n * or dynamic, in which case the call is left untouched and resolves through\n * the runtime dictionary registry.\n */\nconst resolveCompatNamespaceMatch = (\n  t: typeof BabelTypes,\n  callArguments: BabelTypes.CallExpression['arguments'],\n  descriptor: CallerDescriptor\n): CompatNamespaceMatch | undefined => {\n  for (const source of descriptor.namespaceSources) {\n    if (source.from === 'fixed') {\n      return { fullNamespace: source.value };\n    }\n\n    if (source.from === 'argument') {\n      const namespace = getKeyFromArgument(callArguments[source.index], t);\n      if (namespace !== undefined) {\n        return { fullNamespace: namespace, argumentIndex: source.index };\n      }\n      continue;\n    }\n\n    if (source.from === 'option') {\n      const optionsArgument = callArguments[source.argumentIndex];\n      if (!optionsArgument || !t.isObjectExpression(optionsArgument)) continue;\n\n      for (const property of optionsArgument.properties) {\n        if (!t.isObjectProperty(property)) continue;\n        const keyMatches =\n          (t.isIdentifier(property.key) &&\n            property.key.name === source.property) ||\n          (t.isStringLiteral(property.key) &&\n            property.key.value === source.property);\n        if (!keyMatches) continue;\n\n        const namespace = getKeyFromArgument(property.value, t);\n        if (namespace !== undefined) {\n          return {\n            fullNamespace: namespace,\n            optionProperty: property,\n            optionsObject: optionsArgument,\n          };\n        }\n      }\n    }\n  }\n\n  return undefined;\n};\n\nconst isDynamicPackage = (\n  packageName: string\n): packageName is (typeof PACKAGE_LIST_DYNAMIC)[number] =>\n  PACKAGE_LIST_DYNAMIC.includes(\n    packageName as (typeof PACKAGE_LIST_DYNAMIC)[number]\n  );\n\n/**\n * Helper family every `useIntlayer`/`getIntlayer` call from one package import\n * resolves to in the current file. `ssrStatic` is the SSR bundle of a\n * dynamic-mode file: rewritten to the static `useDictionary` (from the\n * package's `/server` entry when it has one — see\n * `SSR_STATIC_IMPORT_SOURCE`) so the server renders static JSON while the\n * client keeps the dynamic loader.\n */\ntype PackageHelperPlan = 'static' | 'dynamic' | 'ssrStatic';\n\n/**\n * Decides, once per package import, which helper family applies to this file.\n * The import rewrite and the per-call rewrite must both derive from this\n * single decision, or the emitted helper and its argument shape diverge.\n *\n * Fetch wins over `ssrStatic`: fetch dictionaries are runtime content, so the\n * server must keep the real fetch path instead of rendering build-time JSON.\n */\nconst resolveHelperPlan = (\n  packageName: string,\n  importMode: ImportMode | undefined,\n  isServer: boolean | undefined,\n  packageHasDynamicCall: boolean,\n  packageHasFetchCall: boolean\n): PackageHelperPlan => {\n  if (!isDynamicPackage(packageName)) return 'static';\n\n  if (importMode === 'fetch' || packageHasFetchCall) return 'dynamic';\n\n  if (importMode === 'dynamic' || packageHasDynamicCall) {\n    return isServer === true ? 'ssrStatic' : 'dynamic';\n  }\n\n  return 'static';\n};\n\n/**\n * Babel plugin that transforms Intlayer function calls and auto-imports dictionaries.\n *\n * This plugin transforms calls to `useIntlayer()` and `getIntlayer()` from various Intlayer\n * packages into optimized dictionary access patterns, automatically importing the required\n * dictionary files based on the configured import mode.\n *\n * ## Supported Input Patterns\n *\n * The plugin recognizes these function calls:\n *\n * ```ts\n * // useIntlayer\n * import { useIntlayer } from 'react-intlayer';\n * import { useIntlayer } from 'next-intlayer';\n *\n * // getIntlayer\n * import { getIntlayer } from 'intlayer';\n *\n * // Usage\n * const content = useIntlayer('app');\n * const content = getIntlayer('app');\n * ```\n *\n * ## Transformation Modes\n *\n * ### Static Mode (default: `importMode = \"static\"`)\n *\n * Imports JSON dictionaries directly and replaces function calls with dictionary access:\n *\n * **Output:**\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import { useDictionary as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash);\n * const content2 = getIntlayer(_dicHash);\n * ```\n *\n * ### Dynamic Mode (`importMode = \"dynamic\"`)\n *\n * Uses dynamic dictionary loading with Suspense support:\n *\n * **Output:**\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import _dicHash_dyn from '../../.intlayer/dynamic_dictionaries/app.mjs';\n * import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash_dyn, 'app');\n * const content2 = getIntlayer(_dicHash);\n * ```\n *\n * ### Fetch Mode (`importMode = \"fetch\"`)\n *\n * Uses fetch-based dictionary loading for remote dictionaries:\n *\n * **Output if `dictionaryModeMap` includes the key with \"fetch\" value:**\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import _dicHash_fetch from '../../.intlayer/fetch_dictionaries/app.mjs';\n * import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash_fetch, \"app\");\n * const content2 = getIntlayer(_dicHash);\n * ```\n *\n * > If `dictionaryModeMap` does not include the key with \"fetch\" value, the plugin will fallback to the dynamic import mode.\n *\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import _dicHash_dyn from '../../.intlayer/dynamic_dictionaries/app.mjs';\n * import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash_dyn, 'app');\n * const content2 = getIntlayer(_dicHash);\n * ```\n */\nexport const intlayerOptimizeBabelPlugin = (babel: {\n  types: typeof BabelTypes;\n}): PluginObject<State> => {\n  const { types: t } = babel;\n\n  return {\n    name: 'babel-plugin-intlayer-transform',\n\n    pre() {\n      this._newStaticImports = new Map();\n      this._newDynamicImports = new Map();\n      this._callerMap = new Map();\n      this._callerPackageMap = new Map();\n      this._compatCallerMap = new Map();\n      this._isIncluded = true;\n      this._hasValidImport = false;\n      this._isDictEntry = false;\n\n      // If optimize is false, skip processing entirely\n      if (this.opts.optimize === false) {\n        this._isIncluded = false;\n        return;\n      }\n\n      // If filesList is provided, check if current file is included\n      const filename = this.file.opts.filename\n        ? normalizePath(this.file.opts.filename)\n        : undefined;\n      if (this.opts.filesList && filename) {\n        const isIncluded = getNormalizedFilesListSet(this.opts.filesList).has(\n          filename\n        );\n\n        if (!isIncluded) {\n          // Force _isIncluded to false to skip processing\n          this._isIncluded = false;\n          return;\n        }\n      }\n    },\n\n    visitor: {\n      /* If this file *is* the dictionaries entry, short-circuit: export {} */\n      Program: {\n        enter(programPath, state) {\n          // Safe access to filename\n          const filename = state.file.opts.filename\n            ? normalizePath(state.file.opts.filename)\n            : undefined;\n          const dictionariesEntryPath = state.opts.dictionariesEntryPath\n            ? normalizePath(state.opts.dictionariesEntryPath)\n            : undefined;\n\n          // Check if this is the correct file to transform\n\n          if (\n            state.opts.replaceDictionaryEntry &&\n            filename === dictionariesEntryPath\n          ) {\n            state._isDictEntry = true;\n\n            // Traverse the program to surgically remove/edit specific parts\n            programPath.traverse({\n              // Remove all import statements (cleaning up 'sssss.json')\n              ImportDeclaration(path) {\n                path.remove();\n              },\n\n              // Find the variable definition and empty the object\n              VariableDeclarator(path) {\n                // We look for: const x = { ... }\n\n                if (t.isObjectExpression(path.node.init)) {\n                  // Set the object properties to an empty array: {}\n                  path.node.init.properties = [];\n                }\n              },\n            });\n\n            // (Optional) Stop other plugins from processing this file further if needed\n            // programPath.stop();\n          }\n        },\n\n        /**\n         * After full traversal, process imports and call expressions, then inject the JSON dictionary imports.\n         *\n         * We do the transformation in Program.exit (via a manual traverse) rather than using\n         * top-level ImportDeclaration/CallExpression visitors. This ensures that if another plugin\n         * (like babel-plugin-intlayer-extract) adds new useIntlayer calls in its Program.exit,\n         * we will see and transform them here because our Program.exit runs after theirs.\n         */\n        exit(programPath, state) {\n          if (state._isDictEntry) return; // nothing else to do – already replaced\n\n          if (!state._isIncluded) return; // early-out if file is not included\n\n          // Compat callers the optimize pass can rewrite (injected by the\n          // compat packages' bundler plugins — nothing is hard-coded here).\n          const rewritableCompatCallers = getRewritableCallers(\n            state.opts.compatCallers ?? []\n          );\n\n          // Manual traversal to process imports and call expressions\n          // This runs AFTER all other plugins' visitors have completed\n          programPath.traverse({\n            /* Inspect every intlayer import before deciding helper rewrites. */\n            ImportDeclaration(path) {\n              const src = path.node.source.value;\n\n              const isNativePackage = PACKAGE_LIST.includes(src);\n              const compatCallersForSource = rewritableCompatCallers.filter(\n                (descriptor) => descriptor.importSources.includes(src)\n              );\n\n              if (!isNativePackage && compatCallersForSource.length === 0) {\n                return;\n              }\n\n              state._hasValidImport = true;\n\n              for (const spec of path.node.specifiers) {\n                if (!t.isImportSpecifier(spec)) continue;\n\n                const importedName = t.isIdentifier(spec.imported)\n                  ? spec.imported.name\n                  : (spec.imported as BabelTypes.StringLiteral).value;\n\n                if (isNativePackage && isCallerName(importedName)) {\n                  state._callerMap?.set(spec.local.name, importedName);\n                  state._callerPackageMap?.set(spec.local.name, src);\n                }\n\n                const compatDescriptor = compatCallersForSource.find(\n                  (descriptor) => descriptor.callerName === importedName\n                );\n                if (compatDescriptor) {\n                  state._compatCallerMap?.set(\n                    spec.local.name,\n                    compatDescriptor\n                  );\n                }\n              }\n            },\n          });\n\n          // Pre-pass to determine if dictionary-level overrides require the\n          // dynamic helper in an otherwise static file, and to disable the\n          // rewrite for compat callers with unresolvable call sites.\n          const packagesWithDynamicCall = new Set<string>();\n          const packagesWithFetchCall = new Set<string>();\n          let compatHasDynamicCall = false;\n          const unresolvableCompatLocalNames = new Set<string>();\n          programPath.traverse({\n            CallExpression(path) {\n              const callee = path.node.callee;\n\n              if (!t.isIdentifier(callee)) return;\n\n              const compatDescriptor = state._compatCallerMap?.get(callee.name);\n              if (compatDescriptor) {\n                const namespaceMatch = resolveCompatNamespaceMatch(\n                  t,\n                  path.node.arguments,\n                  compatDescriptor\n                );\n\n                if (!namespaceMatch) {\n                  // Dynamic/absent namespace: the whole local caller must keep\n                  // its original implementation — rewriting the import while\n                  // leaving this call untouched would hand a raw namespace\n                  // string to the dictionary-accepting helper.\n                  unresolvableCompatLocalNames.add(callee.name);\n                  return;\n                }\n\n                const { dictionaryKey } = splitNamespace(\n                  namespaceMatch.fullNamespace\n                );\n                const compatOverrideMode =\n                  state.opts.dictionaryModeMap?.[dictionaryKey];\n                if (\n                  compatOverrideMode === 'dynamic' ||\n                  compatOverrideMode === 'fetch'\n                ) {\n                  compatHasDynamicCall = true;\n                }\n                return;\n              }\n\n              const originalImportedName = state._callerMap?.get(callee.name);\n              if (originalImportedName !== 'useIntlayer') return;\n\n              const callerPackage = state._callerPackageMap?.get(callee.name);\n              if (!callerPackage) return;\n\n              const key = getKeyFromArgument(path.node.arguments[0], t);\n              if (!key) return;\n\n              const dictionaryOverrideMode =\n                state.opts.dictionaryModeMap?.[key];\n\n              if (dictionaryOverrideMode === 'dynamic') {\n                packagesWithDynamicCall.add(callerPackage);\n              } else if (dictionaryOverrideMode === 'fetch') {\n                packagesWithFetchCall.add(callerPackage);\n              }\n            },\n          });\n\n          for (const localName of unresolvableCompatLocalNames) {\n            state._compatCallerMap?.delete(localName);\n          }\n\n          const getHelperPlan = (packageName: string): PackageHelperPlan =>\n            resolveHelperPlan(\n              packageName,\n              state.opts.importMode,\n              state.opts.isServer,\n              packagesWithDynamicCall.has(packageName),\n              packagesWithFetchCall.has(packageName)\n            );\n\n          // Compat helpers are swapped per file (one import specifier serves\n          // every call), so the dynamic decision is file-level: a global\n          // dynamic/fetch mode or any per-dictionary override flips all\n          // rewritten compat calls to the dynamic helper.\n          const compatUseDynamicHelpers =\n            state.opts.importMode === 'dynamic' ||\n            state.opts.importMode === 'fetch' ||\n            compatHasDynamicCall;\n\n          programPath.traverse({\n            ImportDeclaration(path) {\n              const src = path.node.source.value;\n\n              // Compat caller import rename: point the specifier at the\n              // dictionary-accepting helper exported by the compat package\n              // (`useTranslation` → `useDictionary`), keeping the local alias\n              // so call sites read unchanged. Locals with unresolvable call\n              // sites were dropped from the map and keep the original import.\n              for (const spec of path.node.specifiers) {\n                if (!t.isImportSpecifier(spec)) continue;\n\n                const compatDescriptor = state._compatCallerMap?.get(\n                  spec.local.name\n                );\n                if (!compatDescriptor) continue;\n                if (!compatDescriptor.importSources.includes(src)) continue;\n\n                spec.imported = t.identifier(\n                  compatUseDynamicHelpers\n                    ? compatDescriptor.dynamicReplacement!\n                    : compatDescriptor.staticReplacement!\n                );\n              }\n\n              if (!PACKAGE_LIST.includes(src)) return;\n\n              // Per-import swap, mirrored across bundles — Solid hydration\n              // ids rely on the SSR and client helpers consuming one\n              // resource slot per call alike (see solid-intlayer/server).\n              const helperPlan = getHelperPlan(src);\n              const serverSource =\n                helperPlan === 'ssrStatic'\n                  ? SSR_STATIC_IMPORT_SOURCE[src]\n                  : undefined;\n\n              const helperMap: Record<string, string> =\n                helperPlan === 'dynamic'\n                  ? DYNAMIC_HELPER_MAP\n                  : STATIC_IMPORT_FUNCTION;\n\n              const serverSpecifiers: BabelTypes.ImportSpecifier[] = [];\n\n              for (const spec of path.node.specifiers) {\n                if (!t.isImportSpecifier(spec)) continue;\n\n                const importedName = t.isIdentifier(spec.imported)\n                  ? spec.imported.name\n                  : (spec.imported as BabelTypes.StringLiteral).value;\n\n                if (!isCallerName(importedName)) continue;\n\n                if (serverSource && importedName === 'useIntlayer') {\n                  spec.imported = t.identifier('useDictionary');\n                  serverSpecifiers.push(spec);\n                  continue;\n                }\n\n                const newIdentifier = helperMap[importedName];\n\n                if (newIdentifier) {\n                  // Keep the local alias intact (so calls remain `useIntlayer` /\n                  // `getIntlayer`), but rewrite the imported identifier so it\n                  // points to our helper implementation.\n                  spec.imported = t.identifier(newIdentifier);\n                }\n              }\n\n              if (serverSpecifiers.length > 0 && serverSource) {\n                // Move the helper to the /server entry, keeping any other\n                // specifiers (useLocale, …) on the original import.\n                path.insertAfter(\n                  t.importDeclaration(\n                    serverSpecifiers,\n                    t.stringLiteral(serverSource)\n                  )\n                );\n                path.node.specifiers = path.node.specifiers.filter(\n                  (spec) =>\n                    !serverSpecifiers.includes(\n                      spec as BabelTypes.ImportSpecifier\n                    )\n                );\n                if (path.node.specifiers.length === 0) {\n                  path.remove();\n                }\n              }\n            },\n\n            /* Replace calls: useIntlayer(\"foo\") → useDictionary(_hash) or useDictionaryDynamic(_hash, \"foo\") */\n            CallExpression(path) {\n              const callee = path.node.callee;\n\n              if (!t.isIdentifier(callee)) return;\n\n              // Compat caller rewrite, e.g. (mirroring the SWC plugin):\n              //   static:  useTranslation('about.counter', opts)\n              //            → useDictionary(_hash, 'counter', opts)\n              //   dynamic: useTranslation('about.counter', opts)\n              //            → useDictionaryDynamic(_hash_dyn, 'about', 'counter', opts)\n              //   option:  useI18n({ namespace: 'about' })\n              //            → useDictionary(_hash, {})\n              //   fixed:   useLingui() → useDictionary(_hash)\n              const compatDescriptor = state._compatCallerMap?.get(callee.name);\n              if (compatDescriptor) {\n                const callArguments = path.node.arguments;\n                const namespaceMatch = resolveCompatNamespaceMatch(\n                  t,\n                  callArguments,\n                  compatDescriptor\n                );\n                if (!namespaceMatch) return; // filtered by the pre-pass — stay safe\n\n                state._hasValidImport = true;\n\n                const { dictionaryKey, keyPrefix } = splitNamespace(\n                  namespaceMatch.fullNamespace\n                );\n                const compatOverrideMode =\n                  state.opts.dictionaryModeMap?.[dictionaryKey];\n\n                // The import specifier serves every call in the file, so a\n                // dynamic file receives a dynamic loader for every call.\n                let compatCallMode: ImportMode = 'static';\n                if (compatUseDynamicHelpers) {\n                  if (\n                    compatOverrideMode === 'dynamic' ||\n                    compatOverrideMode === 'fetch'\n                  ) {\n                    compatCallMode = compatOverrideMode;\n                  } else if (\n                    state.opts.importMode === 'dynamic' ||\n                    state.opts.importMode === 'fetch'\n                  ) {\n                    compatCallMode = state.opts.importMode;\n                  } else {\n                    compatCallMode = 'dynamic';\n                  }\n                }\n\n                let dictionaryIdent: BabelTypes.Identifier;\n                if (compatCallMode === 'static') {\n                  let staticIdent = state._newStaticImports?.get(dictionaryKey);\n                  if (!staticIdent) {\n                    staticIdent = makeIdent(dictionaryKey, t);\n                    state._newStaticImports?.set(dictionaryKey, staticIdent);\n                  }\n                  dictionaryIdent = staticIdent;\n                } else {\n                  let dynamicIdent =\n                    state._newDynamicImports?.get(dictionaryKey);\n                  if (!dynamicIdent) {\n                    const hash = getPathHash(dictionaryKey);\n                    const suffix = compatCallMode === 'fetch' ? 'fetch' : 'dyn';\n                    dynamicIdent = t.identifier(`_${hash}_${suffix}`);\n                    state._newDynamicImports?.set(dictionaryKey, dynamicIdent);\n                  }\n                  dictionaryIdent = dynamicIdent;\n                }\n\n                if (namespaceMatch.argumentIndex !== undefined) {\n                  // Positional namespace: replace the string with the\n                  // dictionary, then (dynamic) key and (nested) prefix.\n                  callArguments[namespaceMatch.argumentIndex] = t.identifier(\n                    dictionaryIdent.name\n                  );\n                  const insertAt = namespaceMatch.argumentIndex + 1;\n                  const insertedArguments: BabelTypes.Expression[] = [];\n                  if (compatCallMode !== 'static') {\n                    insertedArguments.push(t.stringLiteral(dictionaryKey));\n                  }\n                  if (keyPrefix) {\n                    insertedArguments.push(t.stringLiteral(keyPrefix));\n                  }\n                  callArguments.splice(insertAt, 0, ...insertedArguments);\n                } else if (compatCallMode !== 'static') {\n                  // Fixed / option namespace, dynamic helper: prepend the\n                  // loader and the dictionary key.\n                  callArguments.unshift(\n                    t.identifier(dictionaryIdent.name),\n                    t.stringLiteral(dictionaryKey)\n                  );\n                } else {\n                  // Fixed / option namespace, static helper: prepend the\n                  // dictionary object.\n                  callArguments.unshift(t.identifier(dictionaryIdent.name));\n                }\n\n                // Option namespace: leave only the key-prefix remainder in the\n                // options object (or drop the property for a plain namespace),\n                // so the runtime helper does not re-apply the dictionary key\n                // as a lookup prefix.\n                if (\n                  namespaceMatch.optionProperty &&\n                  namespaceMatch.optionsObject\n                ) {\n                  if (keyPrefix) {\n                    namespaceMatch.optionProperty.value =\n                      t.stringLiteral(keyPrefix);\n                  } else {\n                    namespaceMatch.optionsObject.properties =\n                      namespaceMatch.optionsObject.properties.filter(\n                        (property) => property !== namespaceMatch.optionProperty\n                      );\n                  }\n                }\n\n                return;\n              }\n\n              const originalImportedName = state._callerMap?.get(callee.name);\n              if (!originalImportedName) return;\n\n              // Ensure we ultimately emit helper imports for files that *invoke*\n              // the hooks, even if they didn't import them directly (edge cases with\n              // re-exports).\n              state._hasValidImport = true;\n\n              const key = getKeyFromArgument(path.node.arguments[0], t);\n              if (!key) return;\n\n              const callerPackage = state._callerPackageMap?.get(callee.name);\n              const importMode = state.opts.importMode;\n              const isUseIntlayer = originalImportedName === 'useIntlayer';\n              const dictionaryOverrideMode =\n                state.opts.dictionaryModeMap?.[key];\n              const helperPlan =\n                callerPackage === undefined\n                  ? 'static'\n                  : getHelperPlan(callerPackage);\n\n              // Decide per-call mode: 'static' | 'dynamic' | 'fetch'.\n              let perCallMode: ImportMode = 'static';\n\n              if (isUseIntlayer && helperPlan === 'dynamic') {\n                if (dictionaryOverrideMode) {\n                  perCallMode = dictionaryOverrideMode;\n                } else if (importMode === 'dynamic' || importMode === 'fetch') {\n                  perCallMode = importMode;\n                }\n              } else if (isUseIntlayer && helperPlan === 'static') {\n                // The global mode is static, but a per-dictionary override can\n                // still force dynamic/fetch for this specific call.\n                if (\n                  dictionaryOverrideMode === 'dynamic' ||\n                  dictionaryOverrideMode === 'fetch'\n                ) {\n                  perCallMode = dictionaryOverrideMode;\n                }\n              }\n\n              let ident: BabelTypes.Identifier;\n\n              if (perCallMode === 'fetch') {\n                // Use fetch dictionaries entry for selected keys\n                let dynamicIdent = state._newDynamicImports?.get(key);\n\n                if (!dynamicIdent) {\n                  const hash = getPathHash(key);\n                  dynamicIdent = t.identifier(`_${hash}_fetch`);\n                  state._newDynamicImports?.set(key, dynamicIdent);\n                }\n                ident = dynamicIdent;\n\n                // Helper: first argument is the dictionary entry, second is the key\n                path.node.arguments = [\n                  t.identifier(ident.name),\n                  ...path.node.arguments,\n                ];\n              } else if (perCallMode === 'dynamic') {\n                // Use dynamic dictionaries entry\n                let dynamicIdent = state._newDynamicImports?.get(key);\n\n                if (!dynamicIdent) {\n                  // Create a unique identifier for dynamic imports by appending a suffix\n                  const hash = getPathHash(key);\n                  dynamicIdent = t.identifier(`_${hash}_dyn`);\n                  state._newDynamicImports?.set(key, dynamicIdent);\n                }\n                ident = dynamicIdent;\n\n                // Dynamic helper: first argument is the dictionary, second is the key.\n                path.node.arguments = [\n                  t.identifier(ident.name),\n                  ...path.node.arguments,\n                ];\n              } else {\n                // Use static imports for getIntlayer or useIntlayer when not using dynamic helpers\n                let staticIdent = state._newStaticImports?.get(key);\n\n                if (!staticIdent) {\n                  staticIdent = makeIdent(key, t);\n                  state._newStaticImports?.set(key, staticIdent);\n                }\n                ident = staticIdent;\n\n                // Static helper (useDictionary / getDictionary): replace key with ident.\n                // After the splice above the key is always at index 0.\n                path.node.arguments[0] = t.identifier(ident.name);\n              }\n            },\n          });\n\n          // Early-out if we touched nothing\n\n          if (!state._hasValidImport) return;\n\n          const file = state.file.opts.filename!;\n          const dictionariesDir = state.opts.dictionariesDir;\n          const dynamicDictionariesDir = state.opts.dynamicDictionariesDir;\n          const fetchDictionariesDir = state.opts.fetchDictionariesDir;\n          const imports: BabelTypes.ImportDeclaration[] = [];\n\n          // Generate static JSON imports (getIntlayer always uses JSON dictionaries)\n          for (const [key, ident] of state._newStaticImports!) {\n            const rel = computeImport(\n              file,\n              dictionariesDir,\n              dynamicDictionariesDir,\n              fetchDictionariesDir,\n              key,\n              'static'\n            );\n\n            const importDeclarationNode = t.importDeclaration(\n              [t.importDefaultSpecifier(t.identifier(ident.name))],\n              t.stringLiteral(rel)\n            );\n\n            // Add 'type: json' attribute for JSON files\n            importDeclarationNode.attributes = [\n              t.importAttribute(t.identifier('type'), t.stringLiteral('json')),\n            ];\n\n            imports.push(importDeclarationNode);\n          }\n\n          // Generate dynamic/fetch imports (for useIntlayer when using dynamic/fetch helpers)\n          for (const [key, ident] of state._newDynamicImports!) {\n            const modeForThisIdent: 'dynamic' | 'fetch' = ident.name.endsWith(\n              '_fetch'\n            )\n              ? 'fetch'\n              : 'dynamic';\n\n            const rel = computeImport(\n              file,\n              dictionariesDir,\n              dynamicDictionariesDir,\n              fetchDictionariesDir,\n              key,\n              modeForThisIdent\n            );\n            imports.push(\n              t.importDeclaration(\n                [t.importDefaultSpecifier(t.identifier(ident.name))],\n                t.stringLiteral(rel)\n              )\n            );\n          }\n\n          if (!imports.length) return;\n\n          /* Keep \"use client\" / \"use server\" directives at the very top. */\n          const bodyPaths = programPath.get(\n            'body'\n          ) as NodePath<BabelTypes.Statement>[];\n          let insertPos = 0;\n          for (const stmtPath of bodyPaths) {\n            const stmt = stmtPath.node;\n\n            if (\n              t.isExpressionStatement(stmt) &&\n              t.isStringLiteral(stmt.expression) &&\n              !stmt.expression.value.startsWith('import') &&\n              !stmt.expression.value.startsWith('require')\n            ) {\n              insertPos += 1;\n            } else {\n              break;\n            }\n          }\n\n          programPath.node.body.splice(insertPos, 0, ...imports);\n        },\n      },\n    },\n  };\n};\n"],"mappings":"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"}

package/dist/esm/babel-plugin-intlayer-purge.mjs

@@ -1,7 +1,7 @@
 import { createPruneContext, makeUsageAnalyzerBabelPlugin } from "./babel-plugin-intlayer-usage-analyzer.mjs";
 import { extractScriptBlocks } from "./extractScriptBlocks.mjs";
 import { buildNestedRenameMapFromContent } from "./babel-plugin-intlayer-field-rename.mjs";
-import { BABEL_PARSER_OPTIONS, SOURCE_FILE_REGEX, buildUsageCheckRegex } from "./transformers.mjs";
+import { BABEL_PARSER_OPTIONS, SOURCE_FILE_REGEX, getUsageCheckRegex } from "./transformers.mjs";
 import { join } from "node:path";
 import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { transformSync } from "@babel/core";
@@ -161,7 +161,7 @@ const analyzeSourceFileSync = (sourceFilePath, pruneContext, compatCallers) => {
 	} catch {
 		return;
 	}
-	const usageCheckRegex = buildUsageCheckRegex((compatCallers ?? []).map((caller) => caller.callerName));
+	const usageCheckRegex = getUsageCheckRegex(compatCallers);
 	if (!usageCheckRegex.test(code)) return;
 	const scriptBlocks = extractScriptBlocks(sourceFilePath, code);
 	for (const block of scriptBlocks) {