@intlayer/babel 8.6.10 → 8.7.0-canary.1

package/dist/cjs/babel-plugin-intlayer-extract.cjs

@@ -2,10 +2,10 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
 const require_extractContent_utils_detectPackageName = require('./extractContent/utils/detectPackageName.cjs');
 const require_extractContent_extractContent = require('./extractContent/extractContent.cjs');
+let node_path = require("node:path");
 let _intlayer_config_colors = require("@intlayer/config/colors");
 _intlayer_config_colors = require_runtime.__toESM(_intlayer_config_colors);
 let _intlayer_config_logger = require("@intlayer/config/logger");
-let node_path = require("node:path");
 let _babel_parser = require("@babel/parser");
 
 //#region src/babel-plugin-intlayer-extract.ts

package/dist/cjs/babel-plugin-intlayer-field-rename.cjs

@@ -0,0 +1,172 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_babel_plugin_intlayer_usage_analyzer = require('./babel-plugin-intlayer-usage-analyzer.cjs');
+
+//#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 (require_babel_plugin_intlayer_usage_analyzer.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
+exports.buildNestedRenameMapFromContent = buildNestedRenameMapFromContent;
+exports.generateShortFieldName = generateShortFieldName;
+exports.makeFieldRenameBabelPlugin = makeFieldRenameBabelPlugin;
+//# sourceMappingURL=babel-plugin-intlayer-field-rename.cjs.map

package/dist/cjs/babel-plugin-intlayer-field-rename.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-intlayer-field-rename.cjs","names":["INTLAYER_CALLER_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":"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"}

package/dist/cjs/babel-plugin-intlayer-optimize.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
-let _intlayer_chokidar_utils = require("@intlayer/chokidar/utils");
 let node_path = require("node:path");
+let _intlayer_chokidar_utils = require("@intlayer/chokidar/utils");
 let _intlayer_config_utils = require("@intlayer/config/utils");
 
 //#region src/babel-plugin-intlayer-optimize.ts

package/dist/cjs/babel-plugin-intlayer-usage-analyzer.cjs

@@ -0,0 +1,171 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#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
+exports.INTLAYER_CALLER_NAMES = INTLAYER_CALLER_NAMES;
+exports.createPruneContext = createPruneContext;
+exports.makeUsageAnalyzerBabelPlugin = makeUsageAnalyzerBabelPlugin;
+//# sourceMappingURL=babel-plugin-intlayer-usage-analyzer.cjs.map

package/dist/cjs/babel-plugin-intlayer-usage-analyzer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-intlayer-usage-analyzer.cjs","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/cjs/extractContent/contentWriter.cjs

@@ -1,9 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 const require_extractContent_utils_extractDictionaryInfo = require('./utils/extractDictionaryInfo.cjs');
+let node_path = require("node:path");
 let node_fs = require("node:fs");
 let node_fs_promises = require("node:fs/promises");
-let node_path = require("node:path");
 let _intlayer_chokidar_build = require("@intlayer/chokidar/build");
 let _intlayer_core_plugins = require("@intlayer/core/plugins");
 let _intlayer_types_nodeType = require("@intlayer/types/nodeType");

package/dist/cjs/extractContent/extractContent.cjs

@@ -7,12 +7,12 @@ const require_extractContent_utils_generateKey = require('./utils/generateKey.cj
 const require_extractContent_utils_shouldExtract = require('./utils/shouldExtract.cjs');
 const require_extractContent_babelProcessor = require('./babelProcessor.cjs');
 const require_extractContent_processTsxFile = require('./processTsxFile.cjs');
+let node_path = require("node:path");
 let _intlayer_config_colors = require("@intlayer/config/colors");
 _intlayer_config_colors = require_runtime.__toESM(_intlayer_config_colors);
 let _intlayer_config_logger = require("@intlayer/config/logger");
 let _intlayer_config_node = require("@intlayer/config/node");
 let node_fs = require("node:fs");
-let node_path = require("node:path");
 let _intlayer_config_utils = require("@intlayer/config/utils");
 let _intlayer_unmerged_dictionaries_entry = require("@intlayer/unmerged-dictionaries-entry");
 let _intlayer_chokidar_cli = require("@intlayer/chokidar/cli");

package/dist/cjs/extractContent/utils/extractDictionaryInfo.cjs

@@ -1,11 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
 const require_extractContent_utils_extractDictionaryKey = require('./extractDictionaryKey.cjs');
+let node_path = require("node:path");
 let _intlayer_chokidar_utils = require("@intlayer/chokidar/utils");
 let _intlayer_config_colors = require("@intlayer/config/colors");
 _intlayer_config_colors = require_runtime.__toESM(_intlayer_config_colors);
 let _intlayer_config_logger = require("@intlayer/config/logger");
-let node_path = require("node:path");
 let _intlayer_config_utils = require("@intlayer/config/utils");
 let _intlayer_unmerged_dictionaries_entry = require("@intlayer/unmerged-dictionaries-entry");
 

package/dist/cjs/extractContent/utils/resolveDictionaryKey.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
-let node_fs = require("node:fs");
 let node_path = require("node:path");
+let node_fs = require("node:fs");
 let _intlayer_unmerged_dictionaries_entry = require("@intlayer/unmerged-dictionaries-entry");
 
 //#region src/extractContent/utils/resolveDictionaryKey.ts

package/dist/cjs/extractScriptBlocks.cjs

@@ -0,0 +1,80 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+let node_path = require("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 = (0, node_path.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
+exports.extractScriptBlocks = extractScriptBlocks;
+exports.injectScriptBlocks = injectScriptBlocks;
+//# sourceMappingURL=extractScriptBlocks.cjs.map

package/dist/cjs/extractScriptBlocks.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractScriptBlocks.cjs","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,6BAAc,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/cjs/getOptimizePluginOptions.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+let node_path = require("node:path");
 let _intlayer_chokidar_utils = require("@intlayer/chokidar/utils");
 let _intlayer_config_node = require("@intlayer/config/node");
-let node_path = require("node:path");
 
 //#region src/getOptimizePluginOptions.ts
 /**