@intlayer/babel 8.6.9 → 8.7.0-canary.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-intlayer-usage-analyzer.mjs","names":[],"sources":["../../src/babel-plugin-intlayer-usage-analyzer.ts"],"sourcesContent":["import type { NodePath, PluginObj, PluginPass } from '@babel/core';\nimport type * as BabelTypes from '@babel/types';\n\n// ── PruneContext types ────────────────────────────────────────────────────────\n\n/**\n * Dictionary field usage result for a single dictionary key.\n *\n *   'all'        → could not determine statically which fields are used;\n *                  keep every field (no pruning possible).\n *   Set<string>  → the exact top-level content field names that were accessed.\n */\nexport type DictionaryFieldUsage = Set<string> | 'all';\n\n/**\n * One node in the nested field-rename tree.\n *\n *   shortName – the compact alias assigned to this field name.\n *   children  – rename table for the next level of user-defined keys inside\n *               this field's value (empty when the value is a leaf / primitive).\n */\nexport type NestedRenameEntry = {\n  shortName: string;\n  children: NestedRenameMap;\n};\n\n/** A level of the field-rename tree, mapping original field names to entries. */\nexport type NestedRenameMap = Map<string, NestedRenameEntry>;\n\n/**\n * Shared mutable state created once by the vite plugin and passed by reference\n * to the usage-analyzer (writer) and the prune/minify plugins (readers).\n *\n * All mutations happen during the usage-analysis `buildStart` phase; readers\n * only access this state during the subsequent `transform` phase.\n */\nexport type PruneContext = {\n  /**\n   * Maps every dictionary key seen in source files to the set of top-level\n   * content fields statically accessed, or `'all'` when the access pattern\n   * could not be determined.\n   */\n  dictionaryKeyToFieldUsageMap: Map<string, DictionaryFieldUsage>;\n\n  /**\n   * Dictionary keys for which the prune/minify step must be skipped entirely\n   * because an edge case was detected during analysis or structure recognition.\n   */\n  dictionariesWithEdgeCases: Set<string>;\n\n  /**\n   * True if at least one source file failed to parse during the analysis phase.\n   * The prune plugin uses this flag conservatively: any dictionary key without\n   * a usage entry might have been referenced by the unparsable file.\n   */\n  hasUnparsableSourceFiles: boolean;\n\n  /**\n   * Maps dictionary keys to the source file paths where the result of\n   * `useIntlayer` / `getIntlayer` was assigned to a plain variable, making\n   * static field analysis impossible.\n   */\n  dictionaryKeysWithUntrackedBindings: Map<string, string[]>;\n\n  /**\n   * Maps each dictionary key to a nested field-rename tree built after the\n   * usage analysis phase (only populated when `build.minify` is active and\n   * the field usage for that dictionary is a finite `Set<string>`).\n   */\n  dictionaryKeyToFieldRenameMap: Map<string, NestedRenameMap>;\n\n  /**\n   * Maps each dictionary key to a per-field list of source locations where\n   * the field value is consumed \"opaquely\" (passed as-is to a child component\n   * or function argument). When a field is opaque AND has nested user-defined\n   * structure, its children must not be renamed.\n   *\n   * Structure: dictionaryKey → fieldName → [\"filePath:line\", …]\n   */\n  dictionaryKeysWithOpaqueTopLevelFields: Map<string, Map<string, string[]>>;\n\n  /**\n   * Dictionary keys for which field-key renaming must be skipped even if a\n   * finite field-usage set was determined.\n   *\n   * Populated for dictionaries whose plain-variable bindings were resolved by\n   * the framework-specific extractor (Vue / Svelte SFCs), because the Babel\n   * rename plugin cannot update the source-code property accesses for those\n   * indirect patterns (Vue `.value.field` / Svelte `$store.field`).\n   *\n   * Pruning and basic minification still apply; only field-key renaming is\n   * suppressed.\n   */\n  dictionariesSkippingFieldRename: Set<string>;\n\n  /**\n   * Plain variable bindings that require a framework-specific secondary pass.\n   *\n   * Populated during the Babel analysis phase for `.vue` and `.svelte` source\n   * files where direct field access is not visible to Babel scope analysis:\n   *   - Vue:    `content.value.fieldName` – the `.value` ref-accessor is hidden\n   *   - Svelte: `$varName.fieldName`     – the `$` prefix creates a new identifier\n   *\n   * Structure: filePath → [{variableName, dictionaryKey}, …]\n   */\n  pendingFrameworkAnalysis: Map<\n    string,\n    { variableName: string; dictionaryKey: string }[]\n  >;\n};\n\nexport const createPruneContext = (): PruneContext => ({\n  dictionaryKeyToFieldUsageMap: new Map(),\n  dictionariesWithEdgeCases: new Set(),\n  hasUnparsableSourceFiles: false,\n  dictionaryKeysWithUntrackedBindings: new Map(),\n  dictionaryKeyToFieldRenameMap: new Map(),\n  dictionaryKeysWithOpaqueTopLevelFields: new Map<\n    string,\n    Map<string, string[]>\n  >(),\n  dictionariesSkippingFieldRename: new Set(),\n  pendingFrameworkAnalysis: new Map(),\n});\n\n// ── Usage-analyzer Babel plugin ───────────────────────────────────────────────\n\n/** Canonical intlayer caller names that trigger usage analysis. */\nexport const INTLAYER_CALLER_NAMES = ['useIntlayer', 'getIntlayer'] as const;\nexport type IntlayerCallerName = (typeof INTLAYER_CALLER_NAMES)[number];\n\n/**\n * Records the usage of a specific dictionary key's fields into `pruneContext`.\n * Merges with any previously recorded usage for the same key.\n */\nconst recordFieldUsage = (\n  pruneContext: PruneContext,\n  dictionaryKey: string,\n  fieldUsage: DictionaryFieldUsage\n): void => {\n  const existingUsage =\n    pruneContext.dictionaryKeyToFieldUsageMap.get(dictionaryKey);\n\n  if (existingUsage === 'all') return; // already saturated\n\n  if (fieldUsage === 'all') {\n    pruneContext.dictionaryKeyToFieldUsageMap.set(dictionaryKey, 'all');\n    return;\n  }\n\n  const mergedFieldSet =\n    existingUsage instanceof Set\n      ? new Set([...existingUsage, ...fieldUsage])\n      : new Set(fieldUsage);\n\n  pruneContext.dictionaryKeyToFieldUsageMap.set(dictionaryKey, mergedFieldSet);\n};\n\n/**\n * Analyses how the result of a single `useIntlayer('key')` / `getIntlayer('key')`\n * call expression is consumed, then records the field usage into `pruneContext`.\n *\n * Recognised patterns:\n *   const { fieldA, fieldB } = useIntlayer('key')  → records {fieldA, fieldB}\n *   useIntlayer('key').fieldA                       → records {fieldA}\n *   useIntlayer('key')['fieldA']                    → records {fieldA}\n *   const { ...rest } = useIntlayer('key')          → records 'all' (spread)\n *   const result = useIntlayer('key')               → records 'all' (untracked binding)\n */\nconst analyzeCallExpressionUsage = (\n  babelTypes: typeof BabelTypes,\n  pruneContext: PruneContext,\n  callExpressionPath: NodePath<BabelTypes.CallExpression>,\n  dictionaryKey: string,\n  currentSourceFilePath: string,\n  isSfcFile: boolean\n): void => {\n  const parentNode = callExpressionPath.parent;\n\n  /** Mark the dictionary key as having an untracked binding in this file. */\n  const markUntrackedBinding = (): void => {\n    const existingPaths =\n      pruneContext.dictionaryKeysWithUntrackedBindings.get(dictionaryKey) ?? [];\n    if (!existingPaths.includes(currentSourceFilePath)) {\n      pruneContext.dictionaryKeysWithUntrackedBindings.set(dictionaryKey, [\n        ...existingPaths,\n        currentSourceFilePath,\n      ]);\n    }\n    recordFieldUsage(pruneContext, dictionaryKey, 'all');\n  };\n\n  /** Record that a field value is consumed opaquely (not further destructured). */\n  const markOpaqueField = (\n    fieldName: string,\n    line: number | undefined\n  ): void => {\n    const fieldToLocations =\n      pruneContext.dictionaryKeysWithOpaqueTopLevelFields.get(dictionaryKey) ??\n      new Map<string, string[]>();\n    const location =\n      line !== undefined\n        ? `${currentSourceFilePath}:${line}`\n        : currentSourceFilePath;\n    const locations = fieldToLocations.get(fieldName) ?? [];\n    if (!locations.includes(location)) locations.push(location);\n    fieldToLocations.set(fieldName, locations);\n    pruneContext.dictionaryKeysWithOpaqueTopLevelFields.set(\n      dictionaryKey,\n      fieldToLocations\n    );\n  };\n\n  /** Register a plain variable binding in an SFC file for a second-pass analysis. */\n  const deferFrameworkAnalysis = (variableName: string): void => {\n    const existing =\n      pruneContext.pendingFrameworkAnalysis.get(currentSourceFilePath) ?? [];\n    if (\n      !existing.some(\n        (e) =>\n          e.variableName === variableName && e.dictionaryKey === dictionaryKey\n      )\n    ) {\n      existing.push({ variableName, dictionaryKey });\n    }\n    pruneContext.pendingFrameworkAnalysis.set(currentSourceFilePath, existing);\n  };\n\n  // ── Pattern 1: const { fieldA, fieldB } = useIntlayer('key') ──────────────\n  if (\n    babelTypes.isVariableDeclarator(parentNode) &&\n    babelTypes.isObjectPattern(parentNode.id)\n  ) {\n    const hasRestElement = parentNode.id.properties.some((prop) =>\n      babelTypes.isRestElement(prop)\n    );\n\n    if (hasRestElement) {\n      recordFieldUsage(pruneContext, dictionaryKey, 'all');\n      return;\n    }\n\n    const accessedFieldNames = new Set<string>();\n    for (const property of parentNode.id.properties) {\n      if (\n        babelTypes.isObjectProperty(property) &&\n        babelTypes.isIdentifier(property.key)\n      ) {\n        accessedFieldNames.add(property.key.name);\n      } else if (\n        babelTypes.isObjectProperty(property) &&\n        babelTypes.isStringLiteral(property.key)\n      ) {\n        accessedFieldNames.add(property.key.value);\n      }\n    }\n\n    recordFieldUsage(pruneContext, dictionaryKey, accessedFieldNames);\n    return;\n  }\n\n  // ── Pattern 2: useIntlayer('key').fieldA / useIntlayer('key')?.fieldA ──────\n  if (\n    (babelTypes.isMemberExpression(parentNode) ||\n      babelTypes.isOptionalMemberExpression(parentNode)) &&\n    (parentNode as BabelTypes.MemberExpression).object ===\n      callExpressionPath.node\n  ) {\n    if (!parentNode.computed && babelTypes.isIdentifier(parentNode.property)) {\n      recordFieldUsage(\n        pruneContext,\n        dictionaryKey,\n        new Set([parentNode.property.name])\n      );\n    } else if (\n      parentNode.computed &&\n      babelTypes.isStringLiteral(parentNode.property)\n    ) {\n      recordFieldUsage(\n        pruneContext,\n        dictionaryKey,\n        new Set([parentNode.property.value])\n      );\n    } else {\n      markUntrackedBinding();\n    }\n    return;\n  }\n\n  // ── Pattern 3: const content = useIntlayer('key') ─────────────────────────\n  if (\n    babelTypes.isVariableDeclarator(parentNode) &&\n    babelTypes.isIdentifier(parentNode.id)\n  ) {\n    const variableName = parentNode.id.name;\n    const variableBinding = callExpressionPath.scope.getBinding(variableName);\n\n    if (!variableBinding) {\n      markUntrackedBinding();\n      return;\n    }\n\n    const accessedTopLevelFieldNames = new Set<string>();\n    let hasUntrackedReferenceAccess = false;\n\n    for (const variableReferencePath of variableBinding.referencePaths) {\n      const referenceParentNode = variableReferencePath.parent;\n\n      if (\n        (babelTypes.isMemberExpression(referenceParentNode) ||\n          babelTypes.isOptionalMemberExpression(referenceParentNode)) &&\n        (referenceParentNode as BabelTypes.MemberExpression).object ===\n          variableReferencePath.node\n      ) {\n        const memberExpressionNode =\n          referenceParentNode as BabelTypes.MemberExpression;\n\n        if (\n          !memberExpressionNode.computed &&\n          babelTypes.isIdentifier(memberExpressionNode.property)\n        ) {\n          const fieldName = memberExpressionNode.property.name;\n          accessedTopLevelFieldNames.add(fieldName);\n\n          // Check if the field value is consumed opaquely (not chained further)\n          const memberExprPath = variableReferencePath.parentPath;\n          const grandParentNode = memberExprPath?.parent;\n          const isChainedFurther =\n            (babelTypes.isMemberExpression(grandParentNode) ||\n              babelTypes.isOptionalMemberExpression(grandParentNode)) &&\n            (grandParentNode as BabelTypes.MemberExpression).object ===\n              memberExprPath?.node;\n\n          if (!isChainedFurther) {\n            markOpaqueField(fieldName, memberExprPath?.node.loc?.start.line);\n          }\n        } else if (\n          memberExpressionNode.computed &&\n          babelTypes.isStringLiteral(memberExpressionNode.property)\n        ) {\n          const fieldName = memberExpressionNode.property.value;\n          accessedTopLevelFieldNames.add(fieldName);\n\n          const memberExprPath = variableReferencePath.parentPath;\n          const grandParentNode = memberExprPath?.parent;\n          const isChainedFurther =\n            (babelTypes.isMemberExpression(grandParentNode) ||\n              babelTypes.isOptionalMemberExpression(grandParentNode)) &&\n            (grandParentNode as BabelTypes.MemberExpression).object ===\n              memberExprPath?.node;\n\n          if (!isChainedFurther) {\n            markOpaqueField(fieldName, memberExprPath?.node.loc?.start.line);\n          }\n        } else {\n          // Dynamic computed access – cannot resolve statically\n          hasUntrackedReferenceAccess = true;\n          break;\n        }\n      } else if (babelTypes.isArrayExpression(referenceParentNode)) {\n        // Ignore array literals (e.g. [content]) – uncommon but benign\n      } else {\n        // Variable used in a non-member-access context (spread, function arg, etc.)\n        hasUntrackedReferenceAccess = true;\n        break;\n      }\n    }\n\n    if (hasUntrackedReferenceAccess) {\n      markUntrackedBinding();\n    } else if (isSfcFile) {\n      // Vue / Svelte SFC: defer to the framework-specific extractor because\n      // Babel scope analysis cannot see through `.value` or `$` indirection.\n      deferFrameworkAnalysis(variableName);\n    } else if (variableBinding.referencePaths.length === 0) {\n      // Non-SFC file with no visible references – conservatively keep all fields.\n      markUntrackedBinding();\n    } else {\n      recordFieldUsage(pruneContext, dictionaryKey, accessedTopLevelFieldNames);\n    }\n    return;\n  }\n\n  // ── Pattern 4: bare call – result is discarded ─────────────────────────────\n  if (babelTypes.isExpressionStatement(parentNode)) {\n    return; // no usage to record\n  }\n\n  // ── Fallback: result passed as argument, used in ternary, etc. ─────────────\n  markUntrackedBinding();\n};\n\n/**\n * Creates a Babel plugin that traverses source files and records which\n * top-level dictionary fields each `useIntlayer` / `getIntlayer` call-site\n * accesses. Results are accumulated into `pruneContext`.\n *\n * This plugin is analysis-only: it does not transform the code (`code: false`\n * should be passed to `transformAsync` when using it).\n */\nexport const makeUsageAnalyzerBabelPlugin =\n  (pruneContext: PruneContext) =>\n  ({ types: babelTypes }: { types: typeof BabelTypes }): PluginObj => ({\n    name: 'intlayer-usage-analyzer',\n    visitor: {\n      Program: {\n        exit: (programPath, state: PluginPass) => {\n          const currentSourceFilePath =\n            state.file.opts.filename ?? 'unknown file';\n          const isSfcFile =\n            currentSourceFilePath.endsWith('.vue') ||\n            currentSourceFilePath.endsWith('.svelte');\n\n          // Phase 1: 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          // Phase 2: analyse each call-site\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              ) {\n                dictionaryKey =\n                  firstArgument.quasis[0].value.cooked ??\n                  firstArgument.quasis[0].value.raw;\n              }\n\n              if (!dictionaryKey) return; // dynamic key – cannot resolve which dictionary\n\n              analyzeCallExpressionUsage(\n                babelTypes,\n                pruneContext,\n                callExpressionPath,\n                dictionaryKey,\n                currentSourceFilePath,\n                isSfcFile\n              );\n            },\n          });\n        },\n      },\n    },\n  });\n"],"mappings":"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"}

package/dist/esm/extractContent/contentWriter.mjs

@@ -1,7 +1,7 @@
 import { resolveContentFilePaths } from "./utils/extractDictionaryInfo.mjs";
+import { dirname, relative } from "node:path";
 import { existsSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
-import { dirname, relative } from "node:path";
 import { buildDictionary, ensureIntlayerBundle, loadContentDeclaration, writeContentDeclaration } from "@intlayer/chokidar/build";
 import { insertContentInDictionary } from "@intlayer/core/plugins";
 import * as NodeTypes from "@intlayer/types/nodeType";

package/dist/esm/extractContent/extractContent.mjs

@@ -5,11 +5,11 @@ import { generateKey } from "./utils/generateKey.mjs";
 import { shouldExtract } from "./utils/shouldExtract.mjs";
 import { extractTsContent } from "./babelProcessor.mjs";
 import { processTsxFile } from "./processTsxFile.mjs";
+import { extname, relative } from "node:path";
 import * as ANSIColors from "@intlayer/config/colors";
 import { colorize, colorizePath, getAppLogger } from "@intlayer/config/logger";
 import { getConfiguration } from "@intlayer/config/node";
 import { readFileSync } from "node:fs";
-import { extname, relative } from "node:path";
 import { getProjectRequire } from "@intlayer/config/utils";
 import { getUnmergedDictionaries } from "@intlayer/unmerged-dictionaries-entry";
 import { detectFormatCommand } from "@intlayer/chokidar/cli";

package/dist/esm/extractContent/utils/extractDictionaryInfo.mjs

@@ -1,8 +1,8 @@
 import { extractDictionaryKey } from "./extractDictionaryKey.mjs";
+import { basename, dirname, extname, relative, resolve } from "node:path";
 import { getFormatFromExtension, resolveRelativePath } from "@intlayer/chokidar/utils";
 import * as ANSIColors from "@intlayer/config/colors";
 import { colorize } from "@intlayer/config/logger";
-import { basename, dirname, extname, relative, resolve } from "node:path";
 import { parseStringPattern } from "@intlayer/config/utils";
 import { getUnmergedDictionaries } from "@intlayer/unmerged-dictionaries-entry";
 

package/dist/esm/extractContent/utils/resolveDictionaryKey.mjs

@@ -1,5 +1,5 @@
-import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { existsSync } from "node:fs";
 import { getUnmergedDictionaries } from "@intlayer/unmerged-dictionaries-entry";
 
 //#region src/extractContent/utils/resolveDictionaryKey.ts

package/dist/esm/extractScriptBlocks.mjs

@@ -0,0 +1,77 @@
+import { extname } from "node:path";
+
+//#region src/extractScriptBlocks.ts
+/**
+* Regex that matches every `<script …>…<\/script>` block in an SFC (Vue or
+* Svelte).  Works for both instance scripts and module/setup scripts.
+*
+* Limitations (shared with `@intlayer/svelte-compiler`'s own approach):
+*  - A literal `<\/script>` inside a string or comment inside the script block
+*    would prematurely close the match.  This is an accepted trade-off for the
+*    vast majority of real-world files.
+*/
+const SFC_SCRIPT_RE = /<script([^>]*)>([\s\S]*?)<\/script>/g;
+/**
+* Extracts all `<script>` blocks from a Vue SFC or Svelte source string,
+* returning each block's text content together with its start/end byte offsets
+* in the original source.
+*
+* Uses the same regex strategy as `@intlayer/svelte-compiler` internally.
+*/
+const extractSFCScriptBlocks = (code) => {
+	const blocks = [];
+	SFC_SCRIPT_RE.lastIndex = 0;
+	for (let match = SFC_SCRIPT_RE.exec(code); match !== null; match = SFC_SCRIPT_RE.exec(code)) {
+		const openingTagLength = 7 + match[1].length + 1;
+		const contentStart = match.index + openingTagLength;
+		const content = match[2];
+		blocks.push({
+			content,
+			contentStartOffset: contentStart,
+			contentEndOffset: contentStart + content.length
+		});
+	}
+	return blocks;
+};
+/**
+* Extracts the script block(s) from a source file, dispatching by extension:
+*
+*  - `.vue` / `.svelte` → searches for `<script>` blocks using a regex
+*    (same approach used by `@intlayer/svelte-compiler`).  Returns one entry
+*    per block found (instance script + module/setup script).
+*    Returns an **empty array** when no `<script>` tag is found, which
+*    happens both for template-only SFCs and for already-compiled JS that
+*    Vite passes to `enforce:'post'` transform hooks.
+*  - everything else → treats the whole file as a single script block and
+*    returns it wrapped in a single-element array.
+*/
+const extractScriptBlocks = (filePath, code) => {
+	const ext = extname(filePath);
+	if (ext === ".vue" || ext === ".svelte") return extractSFCScriptBlocks(code);
+	return [{
+		content: code,
+		contentStartOffset: 0,
+		contentEndOffset: code.length
+	}];
+};
+/**
+* Applies modified script block content back into the original source string.
+*
+* Each entry in `modifications` pairs an original `ScriptBlock` (as returned
+* by `extractScriptBlocks`) with the replacement text for its content.
+* Replacements are applied in reverse offset order so that earlier offsets
+* remain valid while later replacements are being processed.
+*
+* Returns `originalCode` unchanged when `modifications` is empty.
+*/
+const injectScriptBlocks = (originalCode, modifications) => {
+	if (modifications.length === 0) return originalCode;
+	const sorted = [...modifications].sort((a, b) => b.block.contentStartOffset - a.block.contentStartOffset);
+	let result = originalCode;
+	for (const { block, modifiedContent } of sorted) result = result.slice(0, block.contentStartOffset) + modifiedContent + result.slice(block.contentEndOffset);
+	return result;
+};
+
+//#endregion
+export { extractScriptBlocks, injectScriptBlocks };
+//# sourceMappingURL=extractScriptBlocks.mjs.map

package/dist/esm/extractScriptBlocks.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractScriptBlocks.mjs","names":[],"sources":["../../src/extractScriptBlocks.ts"],"sourcesContent":["import { extname } from 'node:path';\n\n/**\n * A script block extracted from an SFC (Vue or Svelte) source file.\n *\n *   `content`            – The raw JS/TS text between the opening and closing\n *                          `<script>` tags (does NOT include the tags).\n *   `contentStartOffset` – Byte offset of `content[0]` in the full source string.\n *   `contentEndOffset`   – Byte offset one past the last byte of `content` in the\n *                          full source string (i.e. `source.slice(start, end) === content`).\n */\nexport type ScriptBlock = {\n  content: string;\n  contentStartOffset: number;\n  contentEndOffset: number;\n};\n\n// ── SFC script extraction ─────────────────────────────────────────────────────\n\n/**\n * Regex that matches every `<script …>…</script>` block in an SFC (Vue or\n * Svelte).  Works for both instance scripts and module/setup scripts.\n *\n * Limitations (shared with `@intlayer/svelte-compiler`'s own approach):\n *  - A literal `</script>` inside a string or comment inside the script block\n *    would prematurely close the match.  This is an accepted trade-off for the\n *    vast majority of real-world files.\n */\nconst SFC_SCRIPT_RE = /<script([^>]*)>([\\s\\S]*?)<\\/script>/g;\n\n/**\n * Extracts all `<script>` blocks from a Vue SFC or Svelte source string,\n * returning each block's text content together with its start/end byte offsets\n * in the original source.\n *\n * Uses the same regex strategy as `@intlayer/svelte-compiler` internally.\n */\nconst extractSFCScriptBlocks = (code: string): ScriptBlock[] => {\n  const blocks: ScriptBlock[] = [];\n  SFC_SCRIPT_RE.lastIndex = 0;\n\n  for (\n    let match = SFC_SCRIPT_RE.exec(code);\n    match !== null;\n    match = SFC_SCRIPT_RE.exec(code)\n  ) {\n    // match[0]: full `<script ATTRS>CONTENT</script>`\n    // match[1]: the attribute string (may be empty)\n    // match[2]: the script content\n    const openingTagLength = '<script'.length + match[1].length + '>'.length;\n    const contentStart = match.index + openingTagLength;\n    const content = match[2];\n    blocks.push({\n      content,\n      contentStartOffset: contentStart,\n      contentEndOffset: contentStart + content.length,\n    });\n  }\n\n  return blocks;\n};\n\n// ── Public API ────────────────────────────────────────────────────────────────\n\n/**\n * Extracts the script block(s) from a source file, dispatching by extension:\n *\n *  - `.vue` / `.svelte` → searches for `<script>` blocks using a regex\n *    (same approach used by `@intlayer/svelte-compiler`).  Returns one entry\n *    per block found (instance script + module/setup script).\n *    Returns an **empty array** when no `<script>` tag is found, which\n *    happens both for template-only SFCs and for already-compiled JS that\n *    Vite passes to `enforce:'post'` transform hooks.\n *  - everything else → treats the whole file as a single script block and\n *    returns it wrapped in a single-element array.\n */\nexport const extractScriptBlocks = (\n  filePath: string,\n  code: string\n): ScriptBlock[] => {\n  const ext = extname(filePath);\n\n  if (ext === '.vue' || ext === '.svelte') {\n    return extractSFCScriptBlocks(code);\n  }\n\n  // Plain JS / TS / JSX / TSX / MJS / CJS – the whole file is the script.\n  return [\n    {\n      content: code,\n      contentStartOffset: 0,\n      contentEndOffset: code.length,\n    },\n  ];\n};\n\n/**\n * Applies modified script block content back into the original source string.\n *\n * Each entry in `modifications` pairs an original `ScriptBlock` (as returned\n * by `extractScriptBlocks`) with the replacement text for its content.\n * Replacements are applied in reverse offset order so that earlier offsets\n * remain valid while later replacements are being processed.\n *\n * Returns `originalCode` unchanged when `modifications` is empty.\n */\nexport const injectScriptBlocks = (\n  originalCode: string,\n  modifications: ReadonlyArray<{\n    block: ScriptBlock;\n    modifiedContent: string;\n  }>\n): string => {\n  if (modifications.length === 0) return originalCode;\n\n  const sorted = [...modifications].sort(\n    (a, b) => b.block.contentStartOffset - a.block.contentStartOffset\n  );\n\n  let result = originalCode;\n  for (const { block, modifiedContent } of sorted) {\n    result =\n      result.slice(0, block.contentStartOffset) +\n      modifiedContent +\n      result.slice(block.contentEndOffset);\n  }\n\n  return result;\n};\n"],"mappings":";;;;;;;;;;;;AA4BA,MAAM,gBAAgB;;;;;;;;AAStB,MAAM,0BAA0B,SAAgC;CAC9D,MAAM,SAAwB,EAAE;AAChC,eAAc,YAAY;AAE1B,MACE,IAAI,QAAQ,cAAc,KAAK,KAAK,EACpC,UAAU,MACV,QAAQ,cAAc,KAAK,KAAK,EAChC;EAIA,MAAM,mBAAmB,IAAmB,MAAM,GAAG,SAAS;EAC9D,MAAM,eAAe,MAAM,QAAQ;EACnC,MAAM,UAAU,MAAM;AACtB,SAAO,KAAK;GACV;GACA,oBAAoB;GACpB,kBAAkB,eAAe,QAAQ;GAC1C,CAAC;;AAGJ,QAAO;;;;;;;;;;;;;;AAiBT,MAAa,uBACX,UACA,SACkB;CAClB,MAAM,MAAM,QAAQ,SAAS;AAE7B,KAAI,QAAQ,UAAU,QAAQ,UAC5B,QAAO,uBAAuB,KAAK;AAIrC,QAAO,CACL;EACE,SAAS;EACT,oBAAoB;EACpB,kBAAkB,KAAK;EACxB,CACF;;;;;;;;;;;;AAaH,MAAa,sBACX,cACA,kBAIW;AACX,KAAI,cAAc,WAAW,EAAG,QAAO;CAEvC,MAAM,SAAS,CAAC,GAAG,cAAc,CAAC,MAC/B,GAAG,MAAM,EAAE,MAAM,qBAAqB,EAAE,MAAM,mBAChD;CAED,IAAI,SAAS;AACb,MAAK,MAAM,EAAE,OAAO,qBAAqB,OACvC,UACE,OAAO,MAAM,GAAG,MAAM,mBAAmB,GACzC,kBACA,OAAO,MAAM,MAAM,iBAAiB;AAGxC,QAAO"}

package/dist/esm/getOptimizePluginOptions.mjs

@@ -1,7 +1,7 @@
 import { __require } from "./_virtual/_rolldown/runtime.mjs";
+import { join } from "node:path";
 import { buildComponentFilesList } from "@intlayer/chokidar/utils";
 import { getConfiguration } from "@intlayer/config/node";
-import { join } from "node:path";
 
 //#region src/getOptimizePluginOptions.ts
 /**

package/dist/esm/index.mjs

@@ -1,3 +1,5 @@
+import { INTLAYER_CALLER_NAMES, createPruneContext, makeUsageAnalyzerBabelPlugin } from "./babel-plugin-intlayer-usage-analyzer.mjs";
+import { extractScriptBlocks, injectScriptBlocks } from "./extractScriptBlocks.mjs";
 import { extractDictionaryKey, extractDictionaryKeyFromPath } from "./extractContent/utils/extractDictionaryKey.mjs";
 import { extractDictionaryInfo, getOutput, resolveContentFilePaths } from "./extractContent/utils/extractDictionaryInfo.mjs";
 import { mergeWithExistingMultilingualDictionary, mergeWithExistingPerLocaleDictionary, writeContentHelper } from "./extractContent/contentWriter.mjs";
@@ -8,7 +10,9 @@ import { generateKey } from "./extractContent/utils/generateKey.mjs";
 import { getComponentName } from "./extractContent/utils/getComponentName.mjs";
 import { extractContent, extractContentSync } from "./extractContent/extractContent.mjs";
 import { intlayerExtractBabelPlugin } from "./babel-plugin-intlayer-extract.mjs";
+import { buildNestedRenameMapFromContent, generateShortFieldName, makeFieldRenameBabelPlugin } from "./babel-plugin-intlayer-field-rename.mjs";
 import { getOptimizePluginOptions } from "./getOptimizePluginOptions.mjs";
 import { intlayerOptimizeBabelPlugin } from "./babel-plugin-intlayer-optimize.mjs";
+import { BABEL_PARSER_OPTIONS, INTLAYER_USAGE_REGEX, SOURCE_FILE_REGEX, analyzeFieldUsageInFile, optimizeSourceFile, renameFieldsInCode, renameFieldsInSourceFile } from "./transformers.mjs";
 
-export { ATTRIBUTES_TO_EXTRACT, SERVER_CAPABLE_PACKAGES, detectPackageName, extractContent, extractContentSync, extractDictionaryInfo, extractDictionaryKey, extractDictionaryKeyFromPath, generateKey, getComponentName, getExtractPluginOptions, getOptimizePluginOptions, getOutput, intlayerExtractBabelPlugin, intlayerOptimizeBabelPlugin, mergeWithExistingMultilingualDictionary, mergeWithExistingPerLocaleDictionary, packageList, resolveContentFilePaths, writeContentHelper };
+export { ATTRIBUTES_TO_EXTRACT, BABEL_PARSER_OPTIONS, INTLAYER_CALLER_NAMES, INTLAYER_USAGE_REGEX, SERVER_CAPABLE_PACKAGES, SOURCE_FILE_REGEX, analyzeFieldUsageInFile, buildNestedRenameMapFromContent, createPruneContext, detectPackageName, extractContent, extractContentSync, extractDictionaryInfo, extractDictionaryKey, extractDictionaryKeyFromPath, extractScriptBlocks, generateKey, generateShortFieldName, getComponentName, getExtractPluginOptions, getOptimizePluginOptions, getOutput, injectScriptBlocks, intlayerExtractBabelPlugin, intlayerOptimizeBabelPlugin, makeFieldRenameBabelPlugin, makeUsageAnalyzerBabelPlugin, mergeWithExistingMultilingualDictionary, mergeWithExistingPerLocaleDictionary, optimizeSourceFile, packageList, renameFieldsInCode, renameFieldsInSourceFile, resolveContentFilePaths, writeContentHelper };

package/dist/esm/transformers.mjs

@@ -0,0 +1,142 @@
+import { makeUsageAnalyzerBabelPlugin } from "./babel-plugin-intlayer-usage-analyzer.mjs";
+import { extractScriptBlocks, injectScriptBlocks } from "./extractScriptBlocks.mjs";
+import { makeFieldRenameBabelPlugin } from "./babel-plugin-intlayer-field-rename.mjs";
+import { intlayerOptimizeBabelPlugin } from "./babel-plugin-intlayer-optimize.mjs";
+import { transformAsync } from "@babel/core";
+
+//#region src/transformers.ts
+/**
+* Babel parser options covering the superset of syntaxes used across all
+* supported frameworks (React / Vue / Svelte / Angular / …).
+*/
+const BABEL_PARSER_OPTIONS = {
+	sourceType: "module",
+	allowImportExportEverywhere: true,
+	plugins: [
+		"typescript",
+		"jsx",
+		"decorators-legacy",
+		"classProperties",
+		"objectRestSpread",
+		"asyncGenerators",
+		"functionBind",
+		"exportDefaultFrom",
+		"exportNamespaceFrom",
+		"dynamicImport",
+		"nullishCoalescingOperator",
+		"optionalChaining"
+	]
+};
+/**
+* Fast pre-check: matches files that could contain intlayer calls.
+* Avoids running Babel on files with no relevant identifiers.
+*/
+const INTLAYER_USAGE_REGEX = /\b(use|get)Intlayer\b/;
+/**
+* Matches source files that are valid targets for usage analysis and Babel
+* transformation. Excludes sourcemap files, declaration files, and other
+* non-source extensions.
+*/
+const SOURCE_FILE_REGEX = /\.(tsx?|[mc]?jsx?|vue|svelte)$/;
+/**
+* Runs the usage-analysis Babel plugin on a single JS/TS code string.
+*
+* This is analysis-only: the transformed code output is discarded.
+* Throws if Babel cannot parse the content.
+*/
+const analyzeScriptContent = async (scriptContent, sourceFilePath, pruneContext) => {
+	await transformAsync(scriptContent, {
+		filename: sourceFilePath,
+		plugins: [makeUsageAnalyzerBabelPlugin(pruneContext)],
+		parserOpts: BABEL_PARSER_OPTIONS,
+		ast: false,
+		code: false
+	});
+};
+/**
+* Runs the usage-analysis Babel plugin on a source file, accumulating
+* field-usage data into `pruneContext`.
+*
+* For Vue / Svelte SFC files, script blocks are extracted before analysis so
+* Babel does not attempt to parse the full SFC syntax (templates, styles, …).
+* For plain JS/TS files, the whole file content is analysed directly.
+*
+* This is analysis-only: the transformed code output is discarded.
+* Throws if Babel cannot parse the file (caller should handle and flag
+* `pruneContext.hasUnparsableSourceFiles`).
+*/
+const analyzeFieldUsageInFile = async (sourceFilePath, code, pruneContext) => {
+	const scriptBlocks = extractScriptBlocks(sourceFilePath, code);
+	for (const block of scriptBlocks) {
+		if (!INTLAYER_USAGE_REGEX.test(block.content)) continue;
+		await analyzeScriptContent(block.content, sourceFilePath, pruneContext);
+	}
+};
+/**
+* Applies field-renaming to a single JS/TS code string (not an SFC).
+*
+* Returns the renamed code string, or `null` if nothing changed or if
+* Babel failed to parse the input (caller should fall back to original code).
+*/
+const renameFieldsInCode = async (code, sourceFilePath, pruneContext) => {
+	try {
+		return (await transformAsync(code, {
+			filename: sourceFilePath,
+			plugins: [makeFieldRenameBabelPlugin(pruneContext)],
+			parserOpts: BABEL_PARSER_OPTIONS,
+			ast: false
+		}))?.code ?? null;
+	} catch {
+		return null;
+	}
+};
+/**
+* Applies field-renaming to a source file, correctly handling both plain
+* JS/TS files and SFC files (Vue / Svelte) by operating on each script block
+* individually and injecting the results back into the original source.
+*
+* Returns the renamed code string, or `null` if nothing changed.
+*/
+const renameFieldsInSourceFile = async (sourceFilePath, code, pruneContext) => {
+	if (pruneContext.dictionaryKeyToFieldRenameMap.size === 0) return null;
+	if (!INTLAYER_USAGE_REGEX.test(code)) return null;
+	const scriptBlocks = extractScriptBlocks(sourceFilePath, code);
+	if (scriptBlocks.length > 0 && (scriptBlocks[0].contentStartOffset > 0 || scriptBlocks.length > 1)) {
+		const modifications = [];
+		for (const block of scriptBlocks) {
+			if (!INTLAYER_USAGE_REGEX.test(block.content)) continue;
+			const renamedCode = await renameFieldsInCode(block.content, sourceFilePath, pruneContext);
+			if (renamedCode && renamedCode !== block.content) modifications.push({
+				block,
+				modifiedContent: renamedCode
+			});
+		}
+		if (modifications.length === 0) return null;
+		return injectScriptBlocks(code, modifications);
+	}
+	return renameFieldsInCode(code, sourceFilePath, pruneContext);
+};
+/**
+* Runs the intlayer optimize Babel plugin on a source file, transforming
+* `useIntlayer('key')` / `getIntlayer('key')` calls into `useDictionary(_hash)`
+* / `getDictionary(_hash)` and injecting the corresponding dictionary imports.
+*
+* Returns `{ code, map }` on success, or `null` if the transformation produced
+* no output.
+*/
+const optimizeSourceFile = async (code, sourceFilePath, options) => {
+	const result = await transformAsync(code, {
+		filename: sourceFilePath,
+		plugins: [[intlayerOptimizeBabelPlugin, options]],
+		parserOpts: BABEL_PARSER_OPTIONS
+	});
+	if (!result?.code) return null;
+	return {
+		code: result.code,
+		map: result.map
+	};
+};
+
+//#endregion
+export { BABEL_PARSER_OPTIONS, INTLAYER_USAGE_REGEX, SOURCE_FILE_REGEX, analyzeFieldUsageInFile, optimizeSourceFile, renameFieldsInCode, renameFieldsInSourceFile };
+//# sourceMappingURL=transformers.mjs.map

package/dist/esm/transformers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformers.mjs","names":[],"sources":["../../src/transformers.ts"],"sourcesContent":["import { type TransformOptions, transformAsync } from '@babel/core';\nimport { makeFieldRenameBabelPlugin } from './babel-plugin-intlayer-field-rename';\nimport {\n  intlayerOptimizeBabelPlugin,\n  type OptimizePluginOptions,\n} from './babel-plugin-intlayer-optimize';\nimport {\n  makeUsageAnalyzerBabelPlugin,\n  type PruneContext,\n} from './babel-plugin-intlayer-usage-analyzer';\nimport { extractScriptBlocks, injectScriptBlocks } from './extractScriptBlocks';\n\n// ── Shared Babel parser configuration ─────────────────────────────────────────\n\n/**\n * Babel parser options covering the superset of syntaxes used across all\n * supported frameworks (React / Vue / Svelte / Angular / …).\n */\nexport const BABEL_PARSER_OPTIONS: NonNullable<TransformOptions['parserOpts']> =\n  {\n    sourceType: 'module',\n    allowImportExportEverywhere: true,\n    plugins: [\n      'typescript',\n      'jsx',\n      'decorators-legacy',\n      'classProperties',\n      'objectRestSpread',\n      'asyncGenerators',\n      'functionBind',\n      'exportDefaultFrom',\n      'exportNamespaceFrom',\n      'dynamicImport',\n      'nullishCoalescingOperator',\n      'optionalChaining',\n    ],\n  };\n\n/**\n * Fast pre-check: matches files that could contain intlayer calls.\n * Avoids running Babel on files with no relevant identifiers.\n */\nexport const INTLAYER_USAGE_REGEX = /\\b(use|get)Intlayer\\b/;\n\n/**\n * Matches source files that are valid targets for usage analysis and Babel\n * transformation. Excludes sourcemap files, declaration files, and other\n * non-source extensions.\n */\nexport const SOURCE_FILE_REGEX = /\\.(tsx?|[mc]?jsx?|vue|svelte)$/;\n\n// ── High-level transformer functions ──────────────────────────────────────────\n\n/**\n * Runs the usage-analysis Babel plugin on a single JS/TS code string.\n *\n * This is analysis-only: the transformed code output is discarded.\n * Throws if Babel cannot parse the content.\n */\nconst analyzeScriptContent = async (\n  scriptContent: string,\n  sourceFilePath: string,\n  pruneContext: PruneContext\n): Promise<void> => {\n  await transformAsync(scriptContent, {\n    filename: sourceFilePath,\n    plugins: [makeUsageAnalyzerBabelPlugin(pruneContext)],\n    parserOpts: BABEL_PARSER_OPTIONS,\n    ast: false,\n    code: false, // analysis only – no output needed\n  });\n};\n\n/**\n * Runs the usage-analysis Babel plugin on a source file, accumulating\n * field-usage data into `pruneContext`.\n *\n * For Vue / Svelte SFC files, script blocks are extracted before analysis so\n * Babel does not attempt to parse the full SFC syntax (templates, styles, …).\n * For plain JS/TS files, the whole file content is analysed directly.\n *\n * This is analysis-only: the transformed code output is discarded.\n * Throws if Babel cannot parse the file (caller should handle and flag\n * `pruneContext.hasUnparsableSourceFiles`).\n */\nexport const analyzeFieldUsageInFile = async (\n  sourceFilePath: string,\n  code: string,\n  pruneContext: PruneContext\n): Promise<void> => {\n  const scriptBlocks = extractScriptBlocks(sourceFilePath, code);\n\n  // For SFC files (Vue / Svelte): scriptBlocks[0].contentStartOffset > 0\n  // means we extracted actual <script> tags from the file.\n  // For plain JS/TS: extractScriptBlocks returns the whole file as a single\n  // block with offset 0, so we fall through to the same path.\n  for (const block of scriptBlocks) {\n    if (!INTLAYER_USAGE_REGEX.test(block.content)) continue;\n    await analyzeScriptContent(block.content, sourceFilePath, pruneContext);\n  }\n};\n\n/**\n * Applies field-renaming to a single JS/TS code string (not an SFC).\n *\n * Returns the renamed code string, or `null` if nothing changed or if\n * Babel failed to parse the input (caller should fall back to original code).\n */\nexport const renameFieldsInCode = async (\n  code: string,\n  sourceFilePath: string,\n  pruneContext: PruneContext\n): Promise<string | null> => {\n  try {\n    const result = await transformAsync(code, {\n      filename: sourceFilePath,\n      plugins: [makeFieldRenameBabelPlugin(pruneContext)],\n      parserOpts: BABEL_PARSER_OPTIONS,\n      ast: false,\n    });\n    return result?.code ?? null;\n  } catch {\n    return null; // parse failure – caller falls back to original code\n  }\n};\n\n/**\n * Applies field-renaming to a source file, correctly handling both plain\n * JS/TS files and SFC files (Vue / Svelte) by operating on each script block\n * individually and injecting the results back into the original source.\n *\n * Returns the renamed code string, or `null` if nothing changed.\n */\nexport const renameFieldsInSourceFile = async (\n  sourceFilePath: string,\n  code: string,\n  pruneContext: PruneContext\n): Promise<string | null> => {\n  if (pruneContext.dictionaryKeyToFieldRenameMap.size === 0) return null;\n  if (!INTLAYER_USAGE_REGEX.test(code)) return null;\n\n  const scriptBlocks = extractScriptBlocks(sourceFilePath, code);\n\n  const isSFC =\n    scriptBlocks.length > 0 &&\n    (scriptBlocks[0].contentStartOffset > 0 || scriptBlocks.length > 1);\n\n  if (isSFC) {\n    // Raw SFC: rename each script block individually and inject back.\n    const modifications: Array<{\n      block: (typeof scriptBlocks)[number];\n      modifiedContent: string;\n    }> = [];\n\n    for (const block of scriptBlocks) {\n      if (!INTLAYER_USAGE_REGEX.test(block.content)) continue;\n\n      const renamedCode = await renameFieldsInCode(\n        block.content,\n        sourceFilePath,\n        pruneContext\n      );\n      if (renamedCode && renamedCode !== block.content) {\n        modifications.push({ block, modifiedContent: renamedCode });\n      }\n    }\n\n    if (modifications.length === 0) return null;\n    return injectScriptBlocks(code, modifications);\n  }\n\n  // Plain JS/TS or compiled SFC (no block delimiters) – rename the whole file.\n  return renameFieldsInCode(code, sourceFilePath, pruneContext);\n};\n\n/**\n * Runs the intlayer optimize Babel plugin on a source file, transforming\n * `useIntlayer('key')` / `getIntlayer('key')` calls into `useDictionary(_hash)`\n * / `getDictionary(_hash)` and injecting the corresponding dictionary imports.\n *\n * Returns `{ code, map }` on success, or `null` if the transformation produced\n * no output.\n */\nexport const optimizeSourceFile = async (\n  code: string,\n  sourceFilePath: string,\n  options: OptimizePluginOptions\n): Promise<{\n  code: string;\n  map: string | object | null | undefined;\n} | null> => {\n  const result = await transformAsync(code, {\n    filename: sourceFilePath,\n    plugins: [[intlayerOptimizeBabelPlugin, options]],\n    parserOpts: BABEL_PARSER_OPTIONS,\n  });\n\n  if (!result?.code) return null;\n\n  return { code: result.code, map: result.map };\n};\n"],"mappings":";;;;;;;;;;;AAkBA,MAAa,uBACX;CACE,YAAY;CACZ,6BAA6B;CAC7B,SAAS;EACP;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD;CACF;;;;;AAMH,MAAa,uBAAuB;;;;;;AAOpC,MAAa,oBAAoB;;;;;;;AAUjC,MAAM,uBAAuB,OAC3B,eACA,gBACA,iBACkB;AAClB,OAAM,eAAe,eAAe;EAClC,UAAU;EACV,SAAS,CAAC,6BAA6B,aAAa,CAAC;EACrD,YAAY;EACZ,KAAK;EACL,MAAM;EACP,CAAC;;;;;;;;;;;;;;AAeJ,MAAa,0BAA0B,OACrC,gBACA,MACA,iBACkB;CAClB,MAAM,eAAe,oBAAoB,gBAAgB,KAAK;AAM9D,MAAK,MAAM,SAAS,cAAc;AAChC,MAAI,CAAC,qBAAqB,KAAK,MAAM,QAAQ,CAAE;AAC/C,QAAM,qBAAqB,MAAM,SAAS,gBAAgB,aAAa;;;;;;;;;AAU3E,MAAa,qBAAqB,OAChC,MACA,gBACA,iBAC2B;AAC3B,KAAI;AAOF,UANe,MAAM,eAAe,MAAM;GACxC,UAAU;GACV,SAAS,CAAC,2BAA2B,aAAa,CAAC;GACnD,YAAY;GACZ,KAAK;GACN,CAAC,GACa,QAAQ;SACjB;AACN,SAAO;;;;;;;;;;AAWX,MAAa,2BAA2B,OACtC,gBACA,MACA,iBAC2B;AAC3B,KAAI,aAAa,8BAA8B,SAAS,EAAG,QAAO;AAClE,KAAI,CAAC,qBAAqB,KAAK,KAAK,CAAE,QAAO;CAE7C,MAAM,eAAe,oBAAoB,gBAAgB,KAAK;AAM9D,KAHE,aAAa,SAAS,MACrB,aAAa,GAAG,qBAAqB,KAAK,aAAa,SAAS,IAExD;EAET,MAAM,gBAGD,EAAE;AAEP,OAAK,MAAM,SAAS,cAAc;AAChC,OAAI,CAAC,qBAAqB,KAAK,MAAM,QAAQ,CAAE;GAE/C,MAAM,cAAc,MAAM,mBACxB,MAAM,SACN,gBACA,aACD;AACD,OAAI,eAAe,gBAAgB,MAAM,QACvC,eAAc,KAAK;IAAE;IAAO,iBAAiB;IAAa,CAAC;;AAI/D,MAAI,cAAc,WAAW,EAAG,QAAO;AACvC,SAAO,mBAAmB,MAAM,cAAc;;AAIhD,QAAO,mBAAmB,MAAM,gBAAgB,aAAa;;;;;;;;;;AAW/D,MAAa,qBAAqB,OAChC,MACA,gBACA,YAIW;CACX,MAAM,SAAS,MAAM,eAAe,MAAM;EACxC,UAAU;EACV,SAAS,CAAC,CAAC,6BAA6B,QAAQ,CAAC;EACjD,YAAY;EACb,CAAC;AAEF,KAAI,CAAC,QAAQ,KAAM,QAAO;AAE1B,QAAO;EAAE,MAAM,OAAO;EAAM,KAAK,OAAO;EAAK"}

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

@@ -0,0 +1,57 @@
+import { NestedRenameMap, PruneContext } from "./babel-plugin-intlayer-usage-analyzer.js";
+import { PluginObj } from "@babel/core";
+import * as BabelTypes from "@babel/types";
+
+//#region src/babel-plugin-intlayer-field-rename.d.ts
+/**
+ * Converts a zero-based index to a short alphabetic identifier.
+ *   0 → 'a', 1 → 'b', …, 25 → 'z', 26 → 'aa', 27 → 'ab', …
+ */
+declare const generateShortFieldName: (index: number) => string;
+/**
+ * Recursively builds a `NestedRenameMap` from a compiled dictionary content
+ * value by traversing the intlayer node structure.
+ *
+ * Rules:
+ *  - If the value has `nodeType: 'translation'`, user-defined fields live
+ *    inside `translation[locale]`. Recurse into the first locale's value.
+ *  - All other intlayer runtime nodes (enumeration, condition, gender, …) are
+ *    treated as leaves — their internal keys must never be renamed.
+ *  - Plain objects are user-defined records: rename their keys (filtered by
+ *    `usedFieldFilter` at the top level) and recurse into each value.
+ *  - Primitives and arrays produce an empty map (no further renaming).
+ *
+ * @param contentValue    - The dictionary content value to analyse.
+ * @param usedFieldFilter - When provided, only keys in this set are included
+ *                          at the current level (matches the usage-analysis
+ *                          results so we don't rename purged fields).
+ */
+declare const buildNestedRenameMapFromContent: (contentValue: unknown, usedFieldFilter?: Set<string>) => NestedRenameMap;
+/**
+ * Creates a Babel plugin that rewrites dictionary content field accesses in
+ * source files to their short aliases defined in
+ * `pruneContext.dictionaryKeyToFieldRenameMap`.
+ *
+ * Handled patterns (mirrors the usage analyser):
+ *
+ *   const { fieldA, fieldB } = useIntlayer('key')
+ *     → const { shortA: fieldA, shortB: fieldB } = useIntlayer('key')
+ *
+ *   useIntlayer('key').fieldA
+ *     → useIntlayer('key').shortA
+ *
+ *   const result = useIntlayer('key');  result.fieldA
+ *     → const result = useIntlayer('key');  result.shortA
+ *
+ * This plugin must run in a separate `transformAsync` pass **before**
+ * `intlayerOptimizeBabelPlugin`, because the latter replaces `useIntlayer`
+ * with `useDictionary`, erasing the dictionary-key information needed here.
+ */
+declare const makeFieldRenameBabelPlugin: (pruneContext: PruneContext) => ({
+  types: babelTypes
+}: {
+  types: typeof BabelTypes;
+}) => PluginObj;
+//#endregion
+export { buildNestedRenameMapFromContent, generateShortFieldName, makeFieldRenameBabelPlugin };
+//# sourceMappingURL=babel-plugin-intlayer-field-rename.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-intlayer-field-rename.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-field-rename.ts"],"mappings":";;;;;;;AAsBA;;cAAa,sBAAA,GAA0B,KAAA;;;AA2BvC;;;;;;;;;;AAqIA;;;;;;cArIa,+BAAA,GACX,YAAA,WACA,eAAA,GAAkB,GAAA,aACjB,eAAA;;;;;;;;;;;;;;;;;;;;;cAkIU,0BAAA,GACV,YAAA,EAAc,YAAA;EACd,KAAA,EAAA;AAAA;EAAyB,KAAA,SAAc,UAAA;AAAA,MAAe,SAAA"}

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

@@ -0,0 +1,119 @@
+import { PluginObj } from "@babel/core";
+import * as BabelTypes from "@babel/types";
+
+//#region src/babel-plugin-intlayer-usage-analyzer.d.ts
+/**
+ * Dictionary field usage result for a single dictionary key.
+ *
+ *   'all'        → could not determine statically which fields are used;
+ *                  keep every field (no pruning possible).
+ *   Set<string>  → the exact top-level content field names that were accessed.
+ */
+type DictionaryFieldUsage = Set<string> | 'all';
+/**
+ * One node in the nested field-rename tree.
+ *
+ *   shortName – the compact alias assigned to this field name.
+ *   children  – rename table for the next level of user-defined keys inside
+ *               this field's value (empty when the value is a leaf / primitive).
+ */
+type NestedRenameEntry = {
+  shortName: string;
+  children: NestedRenameMap;
+};
+/** A level of the field-rename tree, mapping original field names to entries. */
+type NestedRenameMap = Map<string, NestedRenameEntry>;
+/**
+ * Shared mutable state created once by the vite plugin and passed by reference
+ * to the usage-analyzer (writer) and the prune/minify plugins (readers).
+ *
+ * All mutations happen during the usage-analysis `buildStart` phase; readers
+ * only access this state during the subsequent `transform` phase.
+ */
+type PruneContext = {
+  /**
+   * Maps every dictionary key seen in source files to the set of top-level
+   * content fields statically accessed, or `'all'` when the access pattern
+   * could not be determined.
+   */
+  dictionaryKeyToFieldUsageMap: Map<string, DictionaryFieldUsage>;
+  /**
+   * Dictionary keys for which the prune/minify step must be skipped entirely
+   * because an edge case was detected during analysis or structure recognition.
+   */
+  dictionariesWithEdgeCases: Set<string>;
+  /**
+   * True if at least one source file failed to parse during the analysis phase.
+   * The prune plugin uses this flag conservatively: any dictionary key without
+   * a usage entry might have been referenced by the unparsable file.
+   */
+  hasUnparsableSourceFiles: boolean;
+  /**
+   * Maps dictionary keys to the source file paths where the result of
+   * `useIntlayer` / `getIntlayer` was assigned to a plain variable, making
+   * static field analysis impossible.
+   */
+  dictionaryKeysWithUntrackedBindings: Map<string, string[]>;
+  /**
+   * Maps each dictionary key to a nested field-rename tree built after the
+   * usage analysis phase (only populated when `build.minify` is active and
+   * the field usage for that dictionary is a finite `Set<string>`).
+   */
+  dictionaryKeyToFieldRenameMap: Map<string, NestedRenameMap>;
+  /**
+   * Maps each dictionary key to a per-field list of source locations where
+   * the field value is consumed "opaquely" (passed as-is to a child component
+   * or function argument). When a field is opaque AND has nested user-defined
+   * structure, its children must not be renamed.
+   *
+   * Structure: dictionaryKey → fieldName → ["filePath:line", …]
+   */
+  dictionaryKeysWithOpaqueTopLevelFields: Map<string, Map<string, string[]>>;
+  /**
+   * Dictionary keys for which field-key renaming must be skipped even if a
+   * finite field-usage set was determined.
+   *
+   * Populated for dictionaries whose plain-variable bindings were resolved by
+   * the framework-specific extractor (Vue / Svelte SFCs), because the Babel
+   * rename plugin cannot update the source-code property accesses for those
+   * indirect patterns (Vue `.value.field` / Svelte `$store.field`).
+   *
+   * Pruning and basic minification still apply; only field-key renaming is
+   * suppressed.
+   */
+  dictionariesSkippingFieldRename: Set<string>;
+  /**
+   * Plain variable bindings that require a framework-specific secondary pass.
+   *
+   * Populated during the Babel analysis phase for `.vue` and `.svelte` source
+   * files where direct field access is not visible to Babel scope analysis:
+   *   - Vue:    `content.value.fieldName` – the `.value` ref-accessor is hidden
+   *   - Svelte: `$varName.fieldName`     – the `$` prefix creates a new identifier
+   *
+   * Structure: filePath → [{variableName, dictionaryKey}, …]
+   */
+  pendingFrameworkAnalysis: Map<string, {
+    variableName: string;
+    dictionaryKey: string;
+  }[]>;
+};
+declare const createPruneContext: () => PruneContext;
+/** Canonical intlayer caller names that trigger usage analysis. */
+declare const INTLAYER_CALLER_NAMES: readonly ["useIntlayer", "getIntlayer"];
+type IntlayerCallerName = (typeof INTLAYER_CALLER_NAMES)[number];
+/**
+ * Creates a Babel plugin that traverses source files and records which
+ * top-level dictionary fields each `useIntlayer` / `getIntlayer` call-site
+ * accesses. Results are accumulated into `pruneContext`.
+ *
+ * This plugin is analysis-only: it does not transform the code (`code: false`
+ * should be passed to `transformAsync` when using it).
+ */
+declare const makeUsageAnalyzerBabelPlugin: (pruneContext: PruneContext) => ({
+  types: babelTypes
+}: {
+  types: typeof BabelTypes;
+}) => PluginObj;
+//#endregion
+export { DictionaryFieldUsage, INTLAYER_CALLER_NAMES, IntlayerCallerName, NestedRenameEntry, NestedRenameMap, PruneContext, createPruneContext, makeUsageAnalyzerBabelPlugin };
+//# sourceMappingURL=babel-plugin-intlayer-usage-analyzer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-intlayer-usage-analyzer.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-usage-analyzer.ts"],"mappings":";;;;;;AAYA;;;;;KAAY,oBAAA,GAAuB,GAAA;;;;;;;;KASvB,iBAAA;EACV,SAAA;EACA,QAAA,EAAU,eAAA;AAAA;;KAIA,eAAA,GAAkB,GAAA,SAAY,iBAAA;AAS1C;;;;;;;AAAA,KAAY,YAAA;EAiCqB;;;;;EA3B/B,4BAAA,EAA8B,GAAA,SAAY,oBAAA;EA+Db;;;;EAzD7B,yBAAA,EAA2B,GAAA;EAAA;;;;;EAO3B,wBAAA;EAc2C;;;;;EAP3C,mCAAA,EAAqC,GAAA;EA2CrC;;;;;EApCA,6BAAA,EAA+B,GAAA,SAAY,eAAA;EA0ChC;;;;;AAiBb;;;EAjDE,sCAAA,EAAwC,GAAA,SAAY,GAAA;EAiDsB;AAC5E;;;;;AA+QA;;;;;;EAnTE,+BAAA,EAAiC,GAAA;EAsZ/B;;;;;;;;;;EA1YF,wBAAA,EAA0B,GAAA;IAEtB,YAAA;IAAsB,aAAA;EAAA;AAAA;AAAA,cAIf,kBAAA,QAAyB,YAAA;;cAiBzB,qBAAA;AAAA,KACD,kBAAA,WAA6B,qBAAA;;;;;;;;;cA+Q5B,4BAAA,GACV,YAAA,EAAc,YAAA;EACd,KAAA,EAAA;AAAA;EAAyB,KAAA,SAAc,UAAA;AAAA,MAAe,SAAA"}

package/dist/types/extractScriptBlocks.d.ts

@@ -0,0 +1,45 @@
+//#region src/extractScriptBlocks.d.ts
+/**
+ * A script block extracted from an SFC (Vue or Svelte) source file.
+ *
+ *   `content`            – The raw JS/TS text between the opening and closing
+ *                          `<script>` tags (does NOT include the tags).
+ *   `contentStartOffset` – Byte offset of `content[0]` in the full source string.
+ *   `contentEndOffset`   – Byte offset one past the last byte of `content` in the
+ *                          full source string (i.e. `source.slice(start, end) === content`).
+ */
+type ScriptBlock = {
+  content: string;
+  contentStartOffset: number;
+  contentEndOffset: number;
+};
+/**
+ * Extracts the script block(s) from a source file, dispatching by extension:
+ *
+ *  - `.vue` / `.svelte` → searches for `<script>` blocks using a regex
+ *    (same approach used by `@intlayer/svelte-compiler`).  Returns one entry
+ *    per block found (instance script + module/setup script).
+ *    Returns an **empty array** when no `<script>` tag is found, which
+ *    happens both for template-only SFCs and for already-compiled JS that
+ *    Vite passes to `enforce:'post'` transform hooks.
+ *  - everything else → treats the whole file as a single script block and
+ *    returns it wrapped in a single-element array.
+ */
+declare const extractScriptBlocks: (filePath: string, code: string) => ScriptBlock[];
+/**
+ * Applies modified script block content back into the original source string.
+ *
+ * Each entry in `modifications` pairs an original `ScriptBlock` (as returned
+ * by `extractScriptBlocks`) with the replacement text for its content.
+ * Replacements are applied in reverse offset order so that earlier offsets
+ * remain valid while later replacements are being processed.
+ *
+ * Returns `originalCode` unchanged when `modifications` is empty.
+ */
+declare const injectScriptBlocks: (originalCode: string, modifications: ReadonlyArray<{
+  block: ScriptBlock;
+  modifiedContent: string;
+}>) => string;
+//#endregion
+export { ScriptBlock, extractScriptBlocks, injectScriptBlocks };
+//# sourceMappingURL=extractScriptBlocks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extractScriptBlocks.d.ts","names":[],"sources":["../../src/extractScriptBlocks.ts"],"mappings":";;AAWA;;;;;;;;KAAY,WAAA;EACV,OAAA;EACA,kBAAA;EACA,gBAAA;AAAA;;;;;;AA4FF;;;;;;;cA9Ba,mBAAA,GACX,QAAA,UACA,IAAA,aACC,WAAA;;;;;;;;;;;cA2BU,kBAAA,GACX,YAAA,UACA,aAAA,EAAe,aAAA;EACb,KAAA,EAAO,WAAA;EACP,eAAA;AAAA"}