@intlayer/babel 8.6.10 → 8.7.0-canary.0

package/dist/cjs/index.cjs

@@ -1,4 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_babel_plugin_intlayer_usage_analyzer = require('./babel-plugin-intlayer-usage-analyzer.cjs');
+const require_extractScriptBlocks = require('./extractScriptBlocks.cjs');
 const require_extractContent_utils_extractDictionaryKey = require('./extractContent/utils/extractDictionaryKey.cjs');
 const require_extractContent_utils_extractDictionaryInfo = require('./extractContent/utils/extractDictionaryInfo.cjs');
 const require_extractContent_contentWriter = require('./extractContent/contentWriter.cjs');
@@ -9,26 +11,43 @@ const require_extractContent_utils_generateKey = require('./extractContent/utils
 const require_extractContent_utils_getComponentName = require('./extractContent/utils/getComponentName.cjs');
 const require_extractContent_extractContent = require('./extractContent/extractContent.cjs');
 const require_babel_plugin_intlayer_extract = require('./babel-plugin-intlayer-extract.cjs');
+const require_babel_plugin_intlayer_field_rename = require('./babel-plugin-intlayer-field-rename.cjs');
 const require_getOptimizePluginOptions = require('./getOptimizePluginOptions.cjs');
 const require_babel_plugin_intlayer_optimize = require('./babel-plugin-intlayer-optimize.cjs');
+const require_transformers = require('./transformers.cjs');
 
 exports.ATTRIBUTES_TO_EXTRACT = require_extractContent_utils_constants.ATTRIBUTES_TO_EXTRACT;
+exports.BABEL_PARSER_OPTIONS = require_transformers.BABEL_PARSER_OPTIONS;
+exports.INTLAYER_CALLER_NAMES = require_babel_plugin_intlayer_usage_analyzer.INTLAYER_CALLER_NAMES;
+exports.INTLAYER_USAGE_REGEX = require_transformers.INTLAYER_USAGE_REGEX;
 exports.SERVER_CAPABLE_PACKAGES = require_extractContent_utils_constants.SERVER_CAPABLE_PACKAGES;
+exports.SOURCE_FILE_REGEX = require_transformers.SOURCE_FILE_REGEX;
+exports.analyzeFieldUsageInFile = require_transformers.analyzeFieldUsageInFile;
+exports.buildNestedRenameMapFromContent = require_babel_plugin_intlayer_field_rename.buildNestedRenameMapFromContent;
+exports.createPruneContext = require_babel_plugin_intlayer_usage_analyzer.createPruneContext;
 exports.detectPackageName = require_extractContent_utils_detectPackageName.detectPackageName;
 exports.extractContent = require_extractContent_extractContent.extractContent;
 exports.extractContentSync = require_extractContent_extractContent.extractContentSync;
 exports.extractDictionaryInfo = require_extractContent_utils_extractDictionaryInfo.extractDictionaryInfo;
 exports.extractDictionaryKey = require_extractContent_utils_extractDictionaryKey.extractDictionaryKey;
 exports.extractDictionaryKeyFromPath = require_extractContent_utils_extractDictionaryKey.extractDictionaryKeyFromPath;
+exports.extractScriptBlocks = require_extractScriptBlocks.extractScriptBlocks;
 exports.generateKey = require_extractContent_utils_generateKey.generateKey;
+exports.generateShortFieldName = require_babel_plugin_intlayer_field_rename.generateShortFieldName;
 exports.getComponentName = require_extractContent_utils_getComponentName.getComponentName;
 exports.getExtractPluginOptions = require_getExtractPluginOptions.getExtractPluginOptions;
 exports.getOptimizePluginOptions = require_getOptimizePluginOptions.getOptimizePluginOptions;
 exports.getOutput = require_extractContent_utils_extractDictionaryInfo.getOutput;
+exports.injectScriptBlocks = require_extractScriptBlocks.injectScriptBlocks;
 exports.intlayerExtractBabelPlugin = require_babel_plugin_intlayer_extract.intlayerExtractBabelPlugin;
 exports.intlayerOptimizeBabelPlugin = require_babel_plugin_intlayer_optimize.intlayerOptimizeBabelPlugin;
+exports.makeFieldRenameBabelPlugin = require_babel_plugin_intlayer_field_rename.makeFieldRenameBabelPlugin;
+exports.makeUsageAnalyzerBabelPlugin = require_babel_plugin_intlayer_usage_analyzer.makeUsageAnalyzerBabelPlugin;
 exports.mergeWithExistingMultilingualDictionary = require_extractContent_contentWriter.mergeWithExistingMultilingualDictionary;
 exports.mergeWithExistingPerLocaleDictionary = require_extractContent_contentWriter.mergeWithExistingPerLocaleDictionary;
+exports.optimizeSourceFile = require_transformers.optimizeSourceFile;
 exports.packageList = require_extractContent_utils_constants.packageList;
+exports.renameFieldsInCode = require_transformers.renameFieldsInCode;
+exports.renameFieldsInSourceFile = require_transformers.renameFieldsInSourceFile;
 exports.resolveContentFilePaths = require_extractContent_utils_extractDictionaryInfo.resolveContentFilePaths;
 exports.writeContentHelper = require_extractContent_contentWriter.writeContentHelper;

package/dist/cjs/transformers.cjs

@@ -0,0 +1,150 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+const require_babel_plugin_intlayer_usage_analyzer = require('./babel-plugin-intlayer-usage-analyzer.cjs');
+const require_extractScriptBlocks = require('./extractScriptBlocks.cjs');
+const require_babel_plugin_intlayer_field_rename = require('./babel-plugin-intlayer-field-rename.cjs');
+const require_babel_plugin_intlayer_optimize = require('./babel-plugin-intlayer-optimize.cjs');
+let _babel_core = require("@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 (0, _babel_core.transformAsync)(scriptContent, {
+		filename: sourceFilePath,
+		plugins: [require_babel_plugin_intlayer_usage_analyzer.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 = require_extractScriptBlocks.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 (0, _babel_core.transformAsync)(code, {
+			filename: sourceFilePath,
+			plugins: [require_babel_plugin_intlayer_field_rename.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 = require_extractScriptBlocks.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 require_extractScriptBlocks.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 (0, _babel_core.transformAsync)(code, {
+		filename: sourceFilePath,
+		plugins: [[require_babel_plugin_intlayer_optimize.intlayerOptimizeBabelPlugin, options]],
+		parserOpts: BABEL_PARSER_OPTIONS
+	});
+	if (!result?.code) return null;
+	return {
+		code: result.code,
+		map: result.map
+	};
+};
+
+//#endregion
+exports.BABEL_PARSER_OPTIONS = BABEL_PARSER_OPTIONS;
+exports.INTLAYER_USAGE_REGEX = INTLAYER_USAGE_REGEX;
+exports.SOURCE_FILE_REGEX = SOURCE_FILE_REGEX;
+exports.analyzeFieldUsageInFile = analyzeFieldUsageInFile;
+exports.optimizeSourceFile = optimizeSourceFile;
+exports.renameFieldsInCode = renameFieldsInCode;
+exports.renameFieldsInSourceFile = renameFieldsInSourceFile;
+//# sourceMappingURL=transformers.cjs.map

package/dist/cjs/transformers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"transformers.cjs","names":["makeUsageAnalyzerBabelPlugin","extractScriptBlocks","makeFieldRenameBabelPlugin","injectScriptBlocks","intlayerOptimizeBabelPlugin"],"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,uCAAqB,eAAe;EAClC,UAAU;EACV,SAAS,CAACA,0EAA6B,aAAa,CAAC;EACrD,YAAY;EACZ,KAAK;EACL,MAAM;EACP,CAAC;;;;;;;;;;;;;;AAeJ,MAAa,0BAA0B,OACrC,gBACA,MACA,iBACkB;CAClB,MAAM,eAAeC,gDAAoB,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,sCAAqB,MAAM;GACxC,UAAU;GACV,SAAS,CAACC,sEAA2B,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,eAAeD,gDAAoB,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,SAAOE,+CAAmB,MAAM,cAAc;;AAIhD,QAAO,mBAAmB,MAAM,gBAAgB,aAAa;;;;;;;;;;AAW/D,MAAa,qBAAqB,OAChC,MACA,gBACA,YAIW;CACX,MAAM,SAAS,sCAAqB,MAAM;EACxC,UAAU;EACV,SAAS,CAAC,CAACC,oEAA6B,QAAQ,CAAC;EACjD,YAAY;EACb,CAAC;AAEF,KAAI,CAAC,QAAQ,KAAM,QAAO;AAE1B,QAAO;EAAE,MAAM,OAAO;EAAM,KAAK,OAAO;EAAK"}

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

@@ -1,8 +1,8 @@
 import { detectPackageName } from "./extractContent/utils/detectPackageName.mjs";
 import { extractContentSync } from "./extractContent/extractContent.mjs";
+import { relative } from "node:path";
 import * as ANSIColors from "@intlayer/config/colors";
 import { colorize, colorizePath, getAppLogger } from "@intlayer/config/logger";
-import { relative } from "node:path";
 import { parse } from "@babel/parser";
 
 //#region src/babel-plugin-intlayer-extract.ts

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

@@ -0,0 +1,169 @@
+import { INTLAYER_CALLER_NAMES } from "./babel-plugin-intlayer-usage-analyzer.mjs";
+
+//#region src/babel-plugin-intlayer-field-rename.ts
+/**
+* Intlayer internal property names that must never be used as short-name
+* targets. These appear inside content-node values (e.g. `{ nodeType:
+* "translation", … }`) and are read by the intlayer runtime.
+*/
+const RESERVED_CONTENT_FIELD_NAMES = new Set(["nodeType"]);
+/**
+* Converts a zero-based index to a short alphabetic identifier.
+*   0 → 'a', 1 → 'b', …, 25 → 'z', 26 → 'aa', 27 → 'ab', …
+*/
+const generateShortFieldName = (index) => {
+	const ALPHABET = "abcdefghijklmnopqrstuvwxyz";
+	const remainder = index % 26;
+	const quotient = Math.floor(index / 26);
+	return quotient === 0 ? ALPHABET[remainder] : generateShortFieldName(quotient - 1) + ALPHABET[remainder];
+};
+/**
+* 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).
+*/
+const buildNestedRenameMapFromContent = (contentValue, usedFieldFilter) => {
+	if (!contentValue || typeof contentValue !== "object" || Array.isArray(contentValue)) return /* @__PURE__ */ new Map();
+	const record = contentValue;
+	if (typeof record.nodeType === "string") {
+		if (record.translation && typeof record.translation === "object" && !Array.isArray(record.translation)) {
+			const firstLocaleValue = Object.values(record.translation)[0];
+			return buildNestedRenameMapFromContent(firstLocaleValue, usedFieldFilter);
+		}
+		return /* @__PURE__ */ new Map();
+	}
+	const allKeys = Object.keys(record).filter((key) => !RESERVED_CONTENT_FIELD_NAMES.has(key));
+	const sortedKeys = [...usedFieldFilter ? allKeys.filter((key) => usedFieldFilter.has(key)) : allKeys].sort();
+	const renameMap = /* @__PURE__ */ new Map();
+	for (let i = 0; i < sortedKeys.length; i++) {
+		const key = sortedKeys[i];
+		const children = buildNestedRenameMapFromContent(record[key]);
+		renameMap.set(key, {
+			shortName: generateShortFieldName(i),
+			children
+		});
+	}
+	return renameMap;
+};
+/**
+* Walks a MemberExpression chain starting from `startPath`, renaming each
+* property found in `currentRenameMap` at the corresponding nesting level.
+*/
+const walkRenameChain = (babelTypes, startPath, currentRenameMap) => {
+	let refPath = startPath;
+	let renameMap = currentRenameMap;
+	while (renameMap.size > 0) {
+		const parentPath = refPath.parentPath;
+		if (!parentPath) break;
+		const parentNode = parentPath.node;
+		if (!babelTypes.isMemberExpression(parentNode) && !babelTypes.isOptionalMemberExpression(parentNode) || parentNode.object !== refPath.node) break;
+		const memberNode = parentNode;
+		let fieldName;
+		if (!memberNode.computed && babelTypes.isIdentifier(memberNode.property)) fieldName = memberNode.property.name;
+		else if (memberNode.computed && babelTypes.isStringLiteral(memberNode.property)) fieldName = memberNode.property.value;
+		else break;
+		const renameEntry = renameMap.get(fieldName);
+		if (!renameEntry) break;
+		if (!memberNode.computed && babelTypes.isIdentifier(memberNode.property)) memberNode.property.name = renameEntry.shortName;
+		else if (memberNode.computed && babelTypes.isStringLiteral(memberNode.property)) memberNode.property.value = renameEntry.shortName;
+		refPath = parentPath;
+		renameMap = renameEntry.children;
+	}
+};
+/**
+* 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.
+*/
+const makeFieldRenameBabelPlugin = (pruneContext) => ({ types: babelTypes }) => ({
+	name: "intlayer-field-rename",
+	visitor: { Program: { exit: (programPath) => {
+		if (pruneContext.dictionaryKeyToFieldRenameMap.size === 0) return;
+		const intlayerCallerLocalNameMap = /* @__PURE__ */ new Map();
+		programPath.traverse({ ImportDeclaration: (importDeclarationPath) => {
+			for (const importSpecifier of importDeclarationPath.node.specifiers) {
+				if (!babelTypes.isImportSpecifier(importSpecifier)) continue;
+				const importedName = babelTypes.isIdentifier(importSpecifier.imported) ? importSpecifier.imported.name : importSpecifier.imported.value;
+				if (INTLAYER_CALLER_NAMES.includes(importedName)) intlayerCallerLocalNameMap.set(importSpecifier.local.name, importedName);
+			}
+		} });
+		if (intlayerCallerLocalNameMap.size === 0) return;
+		programPath.traverse({ CallExpression: (callExpressionPath) => {
+			const calleeNode = callExpressionPath.node.callee;
+			let localCallerName;
+			if (babelTypes.isIdentifier(calleeNode)) localCallerName = calleeNode.name;
+			else if (babelTypes.isMemberExpression(calleeNode) && babelTypes.isIdentifier(calleeNode.property)) localCallerName = calleeNode.property.name;
+			if (!localCallerName || !intlayerCallerLocalNameMap.has(localCallerName)) return;
+			const callArguments = callExpressionPath.node.arguments;
+			if (callArguments.length === 0) return;
+			const firstArgument = callArguments[0];
+			let dictionaryKey;
+			if (babelTypes.isStringLiteral(firstArgument)) dictionaryKey = firstArgument.value;
+			else if (babelTypes.isTemplateLiteral(firstArgument) && firstArgument.expressions.length === 0 && firstArgument.quasis.length === 1) dictionaryKey = firstArgument.quasis[0].value.cooked ?? firstArgument.quasis[0].value.raw;
+			if (!dictionaryKey) return;
+			const fieldRenameMap = pruneContext.dictionaryKeyToFieldRenameMap.get(dictionaryKey);
+			if (!fieldRenameMap || fieldRenameMap.size === 0) return;
+			const parentNode = callExpressionPath.parent;
+			if (babelTypes.isVariableDeclarator(parentNode) && babelTypes.isObjectPattern(parentNode.id)) {
+				for (const property of parentNode.id.properties) {
+					if (!babelTypes.isObjectProperty(property)) continue;
+					const keyName = babelTypes.isIdentifier(property.key) ? property.key.name : babelTypes.isStringLiteral(property.key) ? property.key.value : null;
+					if (!keyName) continue;
+					const renameEntry = fieldRenameMap.get(keyName);
+					if (!renameEntry) continue;
+					if (property.shorthand) {
+						property.shorthand = false;
+						property.key = babelTypes.identifier(renameEntry.shortName);
+					} else property.key = babelTypes.identifier(renameEntry.shortName);
+					if (renameEntry.children.size > 0 && babelTypes.isIdentifier(property.value)) {
+						const localVarBinding = callExpressionPath.scope.getBinding(property.value.name);
+						if (localVarBinding) for (const refPath of localVarBinding.referencePaths) walkRenameChain(babelTypes, refPath, renameEntry.children);
+					}
+				}
+				return;
+			}
+			if ((babelTypes.isMemberExpression(parentNode) || babelTypes.isOptionalMemberExpression(parentNode)) && parentNode.object === callExpressionPath.node) {
+				walkRenameChain(babelTypes, callExpressionPath, fieldRenameMap);
+				return;
+			}
+			if (babelTypes.isVariableDeclarator(parentNode) && babelTypes.isIdentifier(parentNode.id)) {
+				const variableName = parentNode.id.name;
+				const variableBinding = callExpressionPath.scope.getBinding(variableName);
+				if (!variableBinding) return;
+				for (const variableReferencePath of variableBinding.referencePaths) walkRenameChain(babelTypes, variableReferencePath, fieldRenameMap);
+			}
+		} });
+	} } }
+});
+
+//#endregion
+export { buildNestedRenameMapFromContent, generateShortFieldName, makeFieldRenameBabelPlugin };
+//# sourceMappingURL=babel-plugin-intlayer-field-rename.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-intlayer-field-rename.mjs","names":[],"sources":["../../src/babel-plugin-intlayer-field-rename.ts"],"sourcesContent":["import type { NodePath, PluginObj } 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  return quotient === 0\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 *  - Plain objects are user-defined records: rename their keys (filtered by\n *    `usedFieldFilter` at the top level) and recurse into each value.\n *  - Primitives and arrays produce an empty map (no further renaming).\n *\n * @param contentValue    - The dictionary content value to analyse.\n * @param usedFieldFilter - When provided, only keys in this set are included\n *                          at the current level (matches the usage-analysis\n *                          results so we don't rename purged fields).\n */\nexport const buildNestedRenameMapFromContent = (\n  contentValue: unknown,\n  usedFieldFilter?: Set<string>\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.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, usedFieldFilter);\n    }\n    // All other intlayer nodes have runtime-managed internal structure — return\n    // an empty map so they are treated as leaves.\n    return new Map();\n  }\n\n  // User-defined record: collect non-reserved keys\n  const allKeys = Object.keys(record).filter(\n    (key) => !RESERVED_CONTENT_FIELD_NAMES.has(key)\n  );\n\n  const keysToRename = usedFieldFilter\n    ? allKeys.filter((key) => usedFieldFilter.has(key))\n    : allKeys;\n\n  const sortedKeys = [...keysToRename].sort();\n  const renameMap: NestedRenameMap = new Map();\n\n  for (let i = 0; i < sortedKeys.length; i++) {\n    const key = sortedKeys[i];\n    const children = buildNestedRenameMapFromContent(record[key]); // no filter for nested\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 */\nconst walkRenameChain = (\n  babelTypes: typeof BabelTypes,\n  startPath: NodePath<BabelTypes.Node>,\n  currentRenameMap: NestedRenameMap\n): void => {\n  let refPath: NodePath<BabelTypes.Node> = startPath;\n  let renameMap = currentRenameMap;\n\n  while (renameMap.size > 0) {\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    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 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\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 * 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 }): PluginObj => ({\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              ) {\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 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                        walkRenameChain(\n                          babelTypes,\n                          refPath,\n                          renameEntry.children\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                walkRenameChain(babelTypes, callExpressionPath, fieldRenameMap);\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                  walkRenameChain(\n                    babelTypes,\n                    variableReferencePath,\n                    fieldRenameMap\n                  );\n                }\n              }\n            },\n          });\n        },\n      },\n    },\n  });\n"],"mappings":";;;;;;;;AAgBA,MAAM,+BAA+B,IAAI,IAAI,CAAC,WAAW,CAAC;;;;;AAM1D,MAAa,0BAA0B,UAA0B;CAC/D,MAAM,WAAW;CACjB,MAAM,YAAY,QAAQ;CAC1B,MAAM,WAAW,KAAK,MAAM,QAAQ,GAAgB;AACpD,QAAO,aAAa,IAChB,SAAS,aACT,uBAAuB,WAAW,EAAE,GAAG,SAAS;;;;;;;;;;;;;;;;;;;;AAqBtD,MAAa,mCACX,cACA,oBACoB;AACpB,KACE,CAAC,gBACD,OAAO,iBAAiB,YACxB,MAAM,QAAQ,aAAa,CAE3B,wBAAO,IAAI,KAAK;CAGlB,MAAM,SAAS;AAGf,KAAI,OAAO,OAAO,aAAa,UAAU;AAEvC,MACE,OAAO,eACP,OAAO,OAAO,gBAAgB,YAC9B,CAAC,MAAM,QAAQ,OAAO,YAAY,EAClC;GACA,MAAM,mBAAmB,OAAO,OAC9B,OAAO,YACR,CAAC;AACF,UAAO,gCAAgC,kBAAkB,gBAAgB;;AAI3E,yBAAO,IAAI,KAAK;;CAIlB,MAAM,UAAU,OAAO,KAAK,OAAO,CAAC,QACjC,QAAQ,CAAC,6BAA6B,IAAI,IAAI,CAChD;CAMD,MAAM,aAAa,CAAC,GAJC,kBACjB,QAAQ,QAAQ,QAAQ,gBAAgB,IAAI,IAAI,CAAC,GACjD,QAEgC,CAAC,MAAM;CAC3C,MAAM,4BAA6B,IAAI,KAAK;AAE5C,MAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;EAC1C,MAAM,MAAM,WAAW;EACvB,MAAM,WAAW,gCAAgC,OAAO,KAAK;AAC7D,YAAU,IAAI,KAAK;GAAE,WAAW,uBAAuB,EAAE;GAAE;GAAU,CAAC;;AAGxE,QAAO;;;;;;AAST,MAAM,mBACJ,YACA,WACA,qBACS;CACT,IAAI,UAAqC;CACzC,IAAI,YAAY;AAEhB,QAAO,UAAU,OAAO,GAAG;EACzB,MAAM,aAAa,QAAQ;AAC3B,MAAI,CAAC,WAAY;EAEjB,MAAM,aAAa,WAAW;AAE9B,MACG,CAAC,WAAW,mBAAmB,WAAW,IACzC,CAAC,WAAW,2BAA2B,WAAW,IACnD,WAA2C,WAAW,QAAQ,KAE/D;EAGF,MAAM,aAAa;EACnB,IAAI;AAEJ,MAAI,CAAC,WAAW,YAAY,WAAW,aAAa,WAAW,SAAS,CACtE,aAAY,WAAW,SAAS;WAEhC,WAAW,YACX,WAAW,gBAAgB,WAAW,SAAS,CAE/C,aAAY,WAAW,SAAS;MAEhC;EAGF,MAAM,cAAc,UAAU,IAAI,UAAU;AAC5C,MAAI,CAAC,YAAa;AAGlB,MAAI,CAAC,WAAW,YAAY,WAAW,aAAa,WAAW,SAAS,CACtE,YAAW,SAAS,OAAO,YAAY;WAEvC,WAAW,YACX,WAAW,gBAAgB,WAAW,SAAS,CAE/C,YAAW,SAAS,QAAQ,YAAY;AAG1C,YAAU;AACV,cAAY,YAAY;;;;;;;;;;;;;;;;;;;;;;;AAwB5B,MAAa,8BACV,kBACA,EAAE,OAAO,kBAA2D;CACnE,MAAM;CACN,SAAS,EACP,SAAS,EACP,OAAO,gBAAgB;AACrB,MAAI,aAAa,8BAA8B,SAAS,EAAG;EAG3D,MAAM,6CAA6B,IAAI,KAAqB;AAE5D,cAAY,SAAS,EACnB,oBAAoB,0BAA0B;AAC5C,QAAK,MAAM,mBAAmB,sBAAsB,KACjD,YAAY;AACb,QAAI,CAAC,WAAW,kBAAkB,gBAAgB,CAAE;IAEpD,MAAM,eAAe,WAAW,aAC9B,gBAAgB,SACjB,GACG,gBAAgB,SAAS,OACxB,gBAAgB,SACd;AAEP,QACE,sBAAsB,SACpB,aACD,CAED,4BAA2B,IACzB,gBAAgB,MAAM,MACtB,aACD;;KAIR,CAAC;AAEF,MAAI,2BAA2B,SAAS,EAAG;AAG3C,cAAY,SAAS,EACnB,iBAAiB,uBAAuB;GACtC,MAAM,aAAa,mBAAmB,KAAK;GAC3C,IAAI;AAEJ,OAAI,WAAW,aAAa,WAAW,CACrC,mBAAkB,WAAW;YAE7B,WAAW,mBAAmB,WAAW,IACzC,WAAW,aAAa,WAAW,SAAS,CAE5C,mBAAkB,WAAW,SAAS;AAGxC,OACE,CAAC,mBACD,CAAC,2BAA2B,IAAI,gBAAgB,CAEhD;GAEF,MAAM,gBAAgB,mBAAmB,KAAK;AAC9C,OAAI,cAAc,WAAW,EAAG;GAEhC,MAAM,gBAAgB,cAAc;GACpC,IAAI;AAEJ,OAAI,WAAW,gBAAgB,cAAc,CAC3C,iBAAgB,cAAc;YAE9B,WAAW,kBAAkB,cAAc,IAC3C,cAAc,YAAY,WAAW,KACrC,cAAc,OAAO,WAAW,EAEhC,iBACE,cAAc,OAAO,GAAG,MAAM,UAC9B,cAAc,OAAO,GAAG,MAAM;AAGlC,OAAI,CAAC,cAAe;GAEpB,MAAM,iBACJ,aAAa,8BAA8B,IAAI,cAAc;AAC/D,OAAI,CAAC,kBAAkB,eAAe,SAAS,EAAG;GAElD,MAAM,aAAa,mBAAmB;AAGtC,OACE,WAAW,qBAAqB,WAAW,IAC3C,WAAW,gBAAgB,WAAW,GAAG,EACzC;AACA,SAAK,MAAM,YAAY,WAAW,GAAG,YAAY;AAC/C,SAAI,CAAC,WAAW,iBAAiB,SAAS,CAAE;KAE5C,MAAM,UAAU,WAAW,aAAa,SAAS,IAAI,GACjD,SAAS,IAAI,OACb,WAAW,gBAAgB,SAAS,IAAI,GACtC,SAAS,IAAI,QACb;AACN,SAAI,CAAC,QAAS;KAEd,MAAM,cAAc,eAAe,IAAI,QAAQ;AAC/C,SAAI,CAAC,YAAa;AAIlB,SAAI,SAAS,WAAW;AACtB,eAAS,YAAY;AACrB,eAAS,MAAM,WAAW,WAAW,YAAY,UAAU;WAE3D,UAAS,MAAM,WAAW,WAAW,YAAY,UAAU;AAI7D,SACE,YAAY,SAAS,OAAO,KAC5B,WAAW,aAAa,SAAS,MAAM,EACvC;MACA,MAAM,kBAAkB,mBAAmB,MAAM,WAC9C,SAAS,MAAgC,KAC3C;AACD,UAAI,gBACF,MAAK,MAAM,WAAW,gBAAgB,eACpC,iBACE,YACA,SACA,YAAY,SACb;;;AAKT;;AAIF,QACG,WAAW,mBAAmB,WAAW,IACxC,WAAW,2BAA2B,WAAW,KAClD,WAA2C,WAC1C,mBAAmB,MACrB;AACA,oBAAgB,YAAY,oBAAoB,eAAe;AAC/D;;AAIF,OACE,WAAW,qBAAqB,WAAW,IAC3C,WAAW,aAAa,WAAW,GAAG,EACtC;IACA,MAAM,eAAe,WAAW,GAAG;IACnC,MAAM,kBACJ,mBAAmB,MAAM,WAAW,aAAa;AACnD,QAAI,CAAC,gBAAiB;AAEtB,SAAK,MAAM,yBAAyB,gBAAgB,eAClD,iBACE,YACA,uBACA,eACD;;KAIR,CAAC;IAEL,EACF;CACF"}

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

@@ -1,5 +1,5 @@
-import { getPathHash } from "@intlayer/chokidar/utils";
 import { dirname, join, relative } from "node:path";
+import { getPathHash } from "@intlayer/chokidar/utils";
 import { normalizePath } from "@intlayer/config/utils";
 
 //#region src/babel-plugin-intlayer-optimize.ts

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

@@ -0,0 +1,167 @@
+//#region src/babel-plugin-intlayer-usage-analyzer.ts
+const createPruneContext = () => ({
+	dictionaryKeyToFieldUsageMap: /* @__PURE__ */ new Map(),
+	dictionariesWithEdgeCases: /* @__PURE__ */ new Set(),
+	hasUnparsableSourceFiles: false,
+	dictionaryKeysWithUntrackedBindings: /* @__PURE__ */ new Map(),
+	dictionaryKeyToFieldRenameMap: /* @__PURE__ */ new Map(),
+	dictionaryKeysWithOpaqueTopLevelFields: /* @__PURE__ */ new Map(),
+	dictionariesSkippingFieldRename: /* @__PURE__ */ new Set(),
+	pendingFrameworkAnalysis: /* @__PURE__ */ new Map()
+});
+/** Canonical intlayer caller names that trigger usage analysis. */
+const INTLAYER_CALLER_NAMES = ["useIntlayer", "getIntlayer"];
+/**
+* Records the usage of a specific dictionary key's fields into `pruneContext`.
+* Merges with any previously recorded usage for the same key.
+*/
+const recordFieldUsage = (pruneContext, dictionaryKey, fieldUsage) => {
+	const existingUsage = pruneContext.dictionaryKeyToFieldUsageMap.get(dictionaryKey);
+	if (existingUsage === "all") return;
+	if (fieldUsage === "all") {
+		pruneContext.dictionaryKeyToFieldUsageMap.set(dictionaryKey, "all");
+		return;
+	}
+	const mergedFieldSet = existingUsage instanceof Set ? new Set([...existingUsage, ...fieldUsage]) : new Set(fieldUsage);
+	pruneContext.dictionaryKeyToFieldUsageMap.set(dictionaryKey, mergedFieldSet);
+};
+/**
+* Analyses how the result of a single `useIntlayer('key')` / `getIntlayer('key')`
+* call expression is consumed, then records the field usage into `pruneContext`.
+*
+* Recognised patterns:
+*   const { fieldA, fieldB } = useIntlayer('key')  → records {fieldA, fieldB}
+*   useIntlayer('key').fieldA                       → records {fieldA}
+*   useIntlayer('key')['fieldA']                    → records {fieldA}
+*   const { ...rest } = useIntlayer('key')          → records 'all' (spread)
+*   const result = useIntlayer('key')               → records 'all' (untracked binding)
+*/
+const analyzeCallExpressionUsage = (babelTypes, pruneContext, callExpressionPath, dictionaryKey, currentSourceFilePath, isSfcFile) => {
+	const parentNode = callExpressionPath.parent;
+	/** Mark the dictionary key as having an untracked binding in this file. */
+	const markUntrackedBinding = () => {
+		const existingPaths = pruneContext.dictionaryKeysWithUntrackedBindings.get(dictionaryKey) ?? [];
+		if (!existingPaths.includes(currentSourceFilePath)) pruneContext.dictionaryKeysWithUntrackedBindings.set(dictionaryKey, [...existingPaths, currentSourceFilePath]);
+		recordFieldUsage(pruneContext, dictionaryKey, "all");
+	};
+	/** Record that a field value is consumed opaquely (not further destructured). */
+	const markOpaqueField = (fieldName, line) => {
+		const fieldToLocations = pruneContext.dictionaryKeysWithOpaqueTopLevelFields.get(dictionaryKey) ?? /* @__PURE__ */ new Map();
+		const location = line !== void 0 ? `${currentSourceFilePath}:${line}` : currentSourceFilePath;
+		const locations = fieldToLocations.get(fieldName) ?? [];
+		if (!locations.includes(location)) locations.push(location);
+		fieldToLocations.set(fieldName, locations);
+		pruneContext.dictionaryKeysWithOpaqueTopLevelFields.set(dictionaryKey, fieldToLocations);
+	};
+	/** Register a plain variable binding in an SFC file for a second-pass analysis. */
+	const deferFrameworkAnalysis = (variableName) => {
+		const existing = pruneContext.pendingFrameworkAnalysis.get(currentSourceFilePath) ?? [];
+		if (!existing.some((e) => e.variableName === variableName && e.dictionaryKey === dictionaryKey)) existing.push({
+			variableName,
+			dictionaryKey
+		});
+		pruneContext.pendingFrameworkAnalysis.set(currentSourceFilePath, existing);
+	};
+	if (babelTypes.isVariableDeclarator(parentNode) && babelTypes.isObjectPattern(parentNode.id)) {
+		if (parentNode.id.properties.some((prop) => babelTypes.isRestElement(prop))) {
+			recordFieldUsage(pruneContext, dictionaryKey, "all");
+			return;
+		}
+		const accessedFieldNames = /* @__PURE__ */ new Set();
+		for (const property of parentNode.id.properties) if (babelTypes.isObjectProperty(property) && babelTypes.isIdentifier(property.key)) accessedFieldNames.add(property.key.name);
+		else if (babelTypes.isObjectProperty(property) && babelTypes.isStringLiteral(property.key)) accessedFieldNames.add(property.key.value);
+		recordFieldUsage(pruneContext, dictionaryKey, accessedFieldNames);
+		return;
+	}
+	if ((babelTypes.isMemberExpression(parentNode) || babelTypes.isOptionalMemberExpression(parentNode)) && parentNode.object === callExpressionPath.node) {
+		if (!parentNode.computed && babelTypes.isIdentifier(parentNode.property)) recordFieldUsage(pruneContext, dictionaryKey, new Set([parentNode.property.name]));
+		else if (parentNode.computed && babelTypes.isStringLiteral(parentNode.property)) recordFieldUsage(pruneContext, dictionaryKey, new Set([parentNode.property.value]));
+		else markUntrackedBinding();
+		return;
+	}
+	if (babelTypes.isVariableDeclarator(parentNode) && babelTypes.isIdentifier(parentNode.id)) {
+		const variableName = parentNode.id.name;
+		const variableBinding = callExpressionPath.scope.getBinding(variableName);
+		if (!variableBinding) {
+			markUntrackedBinding();
+			return;
+		}
+		const accessedTopLevelFieldNames = /* @__PURE__ */ new Set();
+		let hasUntrackedReferenceAccess = false;
+		for (const variableReferencePath of variableBinding.referencePaths) {
+			const referenceParentNode = variableReferencePath.parent;
+			if ((babelTypes.isMemberExpression(referenceParentNode) || babelTypes.isOptionalMemberExpression(referenceParentNode)) && referenceParentNode.object === variableReferencePath.node) {
+				const memberExpressionNode = referenceParentNode;
+				if (!memberExpressionNode.computed && babelTypes.isIdentifier(memberExpressionNode.property)) {
+					const fieldName = memberExpressionNode.property.name;
+					accessedTopLevelFieldNames.add(fieldName);
+					const memberExprPath = variableReferencePath.parentPath;
+					const grandParentNode = memberExprPath?.parent;
+					if (!((babelTypes.isMemberExpression(grandParentNode) || babelTypes.isOptionalMemberExpression(grandParentNode)) && grandParentNode.object === memberExprPath?.node)) markOpaqueField(fieldName, memberExprPath?.node.loc?.start.line);
+				} else if (memberExpressionNode.computed && babelTypes.isStringLiteral(memberExpressionNode.property)) {
+					const fieldName = memberExpressionNode.property.value;
+					accessedTopLevelFieldNames.add(fieldName);
+					const memberExprPath = variableReferencePath.parentPath;
+					const grandParentNode = memberExprPath?.parent;
+					if (!((babelTypes.isMemberExpression(grandParentNode) || babelTypes.isOptionalMemberExpression(grandParentNode)) && grandParentNode.object === memberExprPath?.node)) markOpaqueField(fieldName, memberExprPath?.node.loc?.start.line);
+				} else {
+					hasUntrackedReferenceAccess = true;
+					break;
+				}
+			} else if (babelTypes.isArrayExpression(referenceParentNode)) {} else {
+				hasUntrackedReferenceAccess = true;
+				break;
+			}
+		}
+		if (hasUntrackedReferenceAccess) markUntrackedBinding();
+		else if (isSfcFile) deferFrameworkAnalysis(variableName);
+		else if (variableBinding.referencePaths.length === 0) markUntrackedBinding();
+		else recordFieldUsage(pruneContext, dictionaryKey, accessedTopLevelFieldNames);
+		return;
+	}
+	if (babelTypes.isExpressionStatement(parentNode)) return;
+	markUntrackedBinding();
+};
+/**
+* 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).
+*/
+const makeUsageAnalyzerBabelPlugin = (pruneContext) => ({ types: babelTypes }) => ({
+	name: "intlayer-usage-analyzer",
+	visitor: { Program: { exit: (programPath, state) => {
+		const currentSourceFilePath = state.file.opts.filename ?? "unknown file";
+		const isSfcFile = currentSourceFilePath.endsWith(".vue") || currentSourceFilePath.endsWith(".svelte");
+		const intlayerCallerLocalNameMap = /* @__PURE__ */ new Map();
+		programPath.traverse({ ImportDeclaration: (importDeclarationPath) => {
+			for (const importSpecifier of importDeclarationPath.node.specifiers) {
+				if (!babelTypes.isImportSpecifier(importSpecifier)) continue;
+				const importedName = babelTypes.isIdentifier(importSpecifier.imported) ? importSpecifier.imported.name : importSpecifier.imported.value;
+				if (INTLAYER_CALLER_NAMES.includes(importedName)) intlayerCallerLocalNameMap.set(importSpecifier.local.name, importedName);
+			}
+		} });
+		if (intlayerCallerLocalNameMap.size === 0) return;
+		programPath.traverse({ CallExpression: (callExpressionPath) => {
+			const calleeNode = callExpressionPath.node.callee;
+			let localCallerName;
+			if (babelTypes.isIdentifier(calleeNode)) localCallerName = calleeNode.name;
+			else if (babelTypes.isMemberExpression(calleeNode) && babelTypes.isIdentifier(calleeNode.property)) localCallerName = calleeNode.property.name;
+			if (!localCallerName || !intlayerCallerLocalNameMap.has(localCallerName)) return;
+			const callArguments = callExpressionPath.node.arguments;
+			if (callArguments.length === 0) return;
+			const firstArgument = callArguments[0];
+			let dictionaryKey;
+			if (babelTypes.isStringLiteral(firstArgument)) dictionaryKey = firstArgument.value;
+			else if (babelTypes.isTemplateLiteral(firstArgument) && firstArgument.expressions.length === 0 && firstArgument.quasis.length === 1) dictionaryKey = firstArgument.quasis[0].value.cooked ?? firstArgument.quasis[0].value.raw;
+			if (!dictionaryKey) return;
+			analyzeCallExpressionUsage(babelTypes, pruneContext, callExpressionPath, dictionaryKey, currentSourceFilePath, isSfcFile);
+		} });
+	} } }
+});
+
+//#endregion
+export { INTLAYER_CALLER_NAMES, createPruneContext, makeUsageAnalyzerBabelPlugin };
+//# sourceMappingURL=babel-plugin-intlayer-usage-analyzer.mjs.map