@intlayer/babel 7.3.0 → 7.3.2-canary.0

package/dist/esm/{babel-plugin-intlayer.mjs → babel-plugin-intlayer-optimize.mjs}

@@ -2,7 +2,7 @@ import { dirname, join, relative } from "node:path";
 import { getFileHash } from "@intlayer/chokidar";
 import { normalizePath } from "@intlayer/config";
 
-//#region src/babel-plugin-intlayer.ts
+//#region src/babel-plugin-intlayer-optimize.ts
 const PACKAGE_LIST = [
 	"intlayer",
 	"@intlayer/core",
@@ -140,7 +140,7 @@ const computeImport = (fromFile, dictionariesDir, dynamicDictionariesDir, fetchD
 * const content2 = getIntlayer(_dicHash);
 * ```
 */
-const intlayerBabelPlugin = (babel) => {
+const intlayerOptimizeBabelPlugin = (babel) => {
 	const { types: t } = babel;
 	return {
 		name: "babel-plugin-intlayer-transform",
@@ -151,6 +151,10 @@ const intlayerBabelPlugin = (babel) => {
 			this._hasValidImport = false;
 			this._isDictEntry = false;
 			this._useDynamicHelpers = false;
+			if (this.opts.optimize === false) {
+				this._isIncluded = false;
+				return;
+			}
 			const filename = this.file.opts.filename;
 			if (this.opts.filesList && filename) {
 				if (!this.opts.filesList.includes(filename)) {
@@ -159,123 +163,121 @@ const intlayerBabelPlugin = (babel) => {
 				}
 			}
 		},
-		visitor: {
-			Program: {
-				enter(programPath, state) {
-					const filename = state.file.opts.filename;
-					if (state.opts.replaceDictionaryEntry && filename === state.opts.dictionariesEntryPath) {
-						state._isDictEntry = true;
-						programPath.traverse({
-							ImportDeclaration(path) {
-								path.remove();
-							},
-							VariableDeclarator(path) {
-								if (t.isObjectExpression(path.node.init)) path.node.init.properties = [];
-							}
-						});
-					}
-				},
-				exit(programPath, state) {
-					if (state._isDictEntry) return;
-					if (!state._hasValidImport) return;
-					if (!state._isIncluded) return;
-					const file = state.file.opts.filename;
-					const dictionariesDir = state.opts.dictionariesDir;
-					const dynamicDictionariesDir = state.opts.dynamicDictionariesDir;
-					const fetchDictionariesDir = state.opts.fetchDictionariesDir;
-					const imports = [];
-					for (const [key, ident] of state._newStaticImports) {
-						const rel = computeImport(file, dictionariesDir, dynamicDictionariesDir, fetchDictionariesDir, key, "static");
-						const importDeclarationNode = t.importDeclaration([t.importDefaultSpecifier(t.identifier(ident.name))], t.stringLiteral(rel));
-						importDeclarationNode.attributes = [t.importAttribute(t.identifier("type"), t.stringLiteral("json"))];
-						imports.push(importDeclarationNode);
-					}
-					for (const [key, ident] of state._newDynamicImports) {
-						const rel = computeImport(file, dictionariesDir, dynamicDictionariesDir, fetchDictionariesDir, key, ident.name.endsWith("_fetch") ? "live" : "dynamic");
-						imports.push(t.importDeclaration([t.importDefaultSpecifier(t.identifier(ident.name))], t.stringLiteral(rel)));
-					}
-					if (!imports.length) return;
-					const bodyPaths = programPath.get("body");
-					let insertPos = 0;
-					for (const stmtPath of bodyPaths) {
-						const stmt = stmtPath.node;
-						if (t.isExpressionStatement(stmt) && t.isStringLiteral(stmt.expression) && !stmt.expression.value.startsWith("import") && !stmt.expression.value.startsWith("require")) insertPos += 1;
-						else break;
-					}
-					programPath.node.body.splice(insertPos, 0, ...imports);
+		visitor: { Program: {
+			enter(programPath, state) {
+				const filename = state.file.opts.filename;
+				if (state.opts.replaceDictionaryEntry && filename === state.opts.dictionariesEntryPath) {
+					state._isDictEntry = true;
+					programPath.traverse({
+						ImportDeclaration(path) {
+							path.remove();
+						},
+						VariableDeclarator(path) {
+							if (t.isObjectExpression(path.node.init)) path.node.init.properties = [];
+						}
+					});
 				}
 			},
-			ImportDeclaration(path, state) {
+			exit(programPath, state) {
 				if (state._isDictEntry) return;
-				const src = path.node.source.value;
-				if (!PACKAGE_LIST.includes(src)) return;
-				state._hasValidImport = true;
-				for (const spec of path.node.specifiers) {
-					if (!t.isImportSpecifier(spec)) continue;
-					const importedName = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
-					const importMode = state.opts.importMode;
-					const shouldUseDynamicHelpers = (importMode === "dynamic" || importMode === "live") && PACKAGE_LIST_DYNAMIC.includes(src);
-					if (shouldUseDynamicHelpers) state._useDynamicHelpers = true;
-					let helperMap;
-					if (shouldUseDynamicHelpers) helperMap = {
-						...STATIC_IMPORT_FUNCTION,
-						...DYNAMIC_IMPORT_FUNCTION
-					};
-					else helperMap = STATIC_IMPORT_FUNCTION;
-					const newIdentifier = helperMap[importedName];
-					if (newIdentifier) spec.imported = t.identifier(newIdentifier);
+				if (!state._isIncluded) return;
+				programPath.traverse({
+					ImportDeclaration(path) {
+						const src = path.node.source.value;
+						if (!PACKAGE_LIST.includes(src)) return;
+						state._hasValidImport = true;
+						for (const spec of path.node.specifiers) {
+							if (!t.isImportSpecifier(spec)) continue;
+							const importedName = t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value;
+							const importMode = state.opts.importMode;
+							const shouldUseDynamicHelpers = (importMode === "dynamic" || importMode === "live") && PACKAGE_LIST_DYNAMIC.includes(src);
+							if (shouldUseDynamicHelpers) state._useDynamicHelpers = true;
+							let helperMap;
+							if (shouldUseDynamicHelpers) helperMap = {
+								...STATIC_IMPORT_FUNCTION,
+								...DYNAMIC_IMPORT_FUNCTION
+							};
+							else helperMap = STATIC_IMPORT_FUNCTION;
+							const newIdentifier = helperMap[importedName];
+							if (newIdentifier) spec.imported = t.identifier(newIdentifier);
+						}
+					},
+					CallExpression(path) {
+						const callee = path.node.callee;
+						if (!t.isIdentifier(callee)) return;
+						if (!CALLER_LIST.includes(callee.name)) return;
+						state._hasValidImport = true;
+						const arg = path.node.arguments[0];
+						if (!arg || !t.isStringLiteral(arg)) return;
+						const key = arg.value;
+						const importMode = state.opts.importMode;
+						const isUseIntlayer = callee.name === "useIntlayer";
+						const useDynamicHelpers = Boolean(state._useDynamicHelpers);
+						let perCallMode = "static";
+						if (isUseIntlayer && useDynamicHelpers) {
+							if (importMode === "dynamic") perCallMode = "dynamic";
+							else if (importMode === "live") perCallMode = (state.opts.liveSyncKeys ?? []).includes(key) ? "live" : "dynamic";
+						}
+						let ident;
+						if (perCallMode === "live") {
+							let dynamicIdent = state._newDynamicImports?.get(key);
+							if (!dynamicIdent) {
+								const hash = getFileHash(key);
+								dynamicIdent = t.identifier(`_${hash}_fetch`);
+								state._newDynamicImports?.set(key, dynamicIdent);
+							}
+							ident = dynamicIdent;
+							path.node.arguments = [t.identifier(ident.name), ...path.node.arguments];
+						} else if (perCallMode === "dynamic") {
+							let dynamicIdent = state._newDynamicImports?.get(key);
+							if (!dynamicIdent) {
+								const hash = getFileHash(key);
+								dynamicIdent = t.identifier(`_${hash}_dyn`);
+								state._newDynamicImports?.set(key, dynamicIdent);
+							}
+							ident = dynamicIdent;
+							path.node.arguments = [t.identifier(ident.name), ...path.node.arguments];
+						} else {
+							let staticIdent = state._newStaticImports?.get(key);
+							if (!staticIdent) {
+								staticIdent = makeIdent(key, t);
+								state._newStaticImports?.set(key, staticIdent);
+							}
+							ident = staticIdent;
+							path.node.arguments[0] = t.identifier(ident.name);
+						}
+					}
+				});
+				if (!state._hasValidImport) return;
+				const file = state.file.opts.filename;
+				const dictionariesDir = state.opts.dictionariesDir;
+				const dynamicDictionariesDir = state.opts.dynamicDictionariesDir;
+				const fetchDictionariesDir = state.opts.fetchDictionariesDir;
+				const imports = [];
+				for (const [key, ident] of state._newStaticImports) {
+					const rel = computeImport(file, dictionariesDir, dynamicDictionariesDir, fetchDictionariesDir, key, "static");
+					const importDeclarationNode = t.importDeclaration([t.importDefaultSpecifier(t.identifier(ident.name))], t.stringLiteral(rel));
+					importDeclarationNode.attributes = [t.importAttribute(t.identifier("type"), t.stringLiteral("json"))];
+					imports.push(importDeclarationNode);
 				}
-			},
-			CallExpression(path, state) {
-				if (state._isDictEntry) return;
-				const callee = path.node.callee;
-				if (!t.isIdentifier(callee)) return;
-				if (!CALLER_LIST.includes(callee.name)) return;
-				state._hasValidImport = true;
-				const arg = path.node.arguments[0];
-				if (!arg || !t.isStringLiteral(arg)) return;
-				const key = arg.value;
-				const importMode = state.opts.importMode;
-				const isUseIntlayer = callee.name === "useIntlayer";
-				const useDynamicHelpers = Boolean(state._useDynamicHelpers);
-				let perCallMode = "static";
-				if (isUseIntlayer && useDynamicHelpers) {
-					if (importMode === "dynamic") perCallMode = "dynamic";
-					else if (importMode === "live") perCallMode = (state.opts.liveSyncKeys ?? []).includes(key) ? "live" : "dynamic";
+				for (const [key, ident] of state._newDynamicImports) {
+					const rel = computeImport(file, dictionariesDir, dynamicDictionariesDir, fetchDictionariesDir, key, ident.name.endsWith("_fetch") ? "live" : "dynamic");
+					imports.push(t.importDeclaration([t.importDefaultSpecifier(t.identifier(ident.name))], t.stringLiteral(rel)));
 				}
-				let ident;
-				if (perCallMode === "live") {
-					let dynamicIdent = state._newDynamicImports?.get(key);
-					if (!dynamicIdent) {
-						const hash = getFileHash(key);
-						dynamicIdent = t.identifier(`_${hash}_fetch`);
-						state._newDynamicImports?.set(key, dynamicIdent);
-					}
-					ident = dynamicIdent;
-					path.node.arguments = [t.identifier(ident.name), ...path.node.arguments];
-				} else if (perCallMode === "dynamic") {
-					let dynamicIdent = state._newDynamicImports?.get(key);
-					if (!dynamicIdent) {
-						const hash = getFileHash(key);
-						dynamicIdent = t.identifier(`_${hash}_dyn`);
-						state._newDynamicImports?.set(key, dynamicIdent);
-					}
-					ident = dynamicIdent;
-					path.node.arguments = [t.identifier(ident.name), ...path.node.arguments];
-				} else {
-					let staticIdent = state._newStaticImports?.get(key);
-					if (!staticIdent) {
-						staticIdent = makeIdent(key, t);
-						state._newStaticImports?.set(key, staticIdent);
-					}
-					ident = staticIdent;
-					path.node.arguments[0] = t.identifier(ident.name);
+				if (!imports.length) return;
+				const bodyPaths = programPath.get("body");
+				let insertPos = 0;
+				for (const stmtPath of bodyPaths) {
+					const stmt = stmtPath.node;
+					if (t.isExpressionStatement(stmt) && t.isStringLiteral(stmt.expression) && !stmt.expression.value.startsWith("import") && !stmt.expression.value.startsWith("require")) insertPos += 1;
+					else break;
 				}
+				programPath.node.body.splice(insertPos, 0, ...imports);
 			}
-		}
+		} }
 	};
 };
 
 //#endregion
-export { intlayerBabelPlugin };
-//# sourceMappingURL=babel-plugin-intlayer.mjs.map
+export { intlayerOptimizeBabelPlugin };
+//# sourceMappingURL=babel-plugin-intlayer-optimize.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-intlayer-optimize.mjs","names":["helperMap: Record<string, string>","perCallMode: 'static' | 'dynamic' | 'live'","ident: BabelTypes.Identifier","imports: BabelTypes.ImportDeclaration[]"],"sources":["../../src/babel-plugin-intlayer-optimize.ts"],"sourcesContent":["import { dirname, join, relative } from 'node:path';\nimport type { NodePath, PluginObj, PluginPass } from '@babel/core';\nimport type * as BabelTypes from '@babel/types';\nimport { getFileHash } from '@intlayer/chokidar';\nimport { normalizePath } from '@intlayer/config';\n\n/* ────────────────────────────────────────── constants ───────────────────── */\n\nconst PACKAGE_LIST = [\n  'intlayer',\n  '@intlayer/core',\n  'react-intlayer',\n  'react-intlayer/client',\n  'react-intlayer/server',\n  'next-intlayer',\n  'next-intlayer/client',\n  'next-intlayer/server',\n  'svelte-intlayer',\n  'vue-intlayer',\n  'angular-intlayer',\n  'preact-intlayer',\n  'solid-intlayer',\n];\n\nconst CALLER_LIST = ['useIntlayer', 'getIntlayer'] as const;\n\n/**\n * Packages that support dynamic import\n */\nconst PACKAGE_LIST_DYNAMIC = [\n  'react-intlayer',\n  'react-intlayer/client',\n  'react-intlayer/server',\n  'next-intlayer',\n  'next-intlayer/client',\n  'next-intlayer/server',\n  'preact-intlayer',\n  'vue-intlayer',\n  'solid-intlayer',\n  'svelte-intlayer',\n  'angular-intlayer',\n] as const;\n\nconst STATIC_IMPORT_FUNCTION = {\n  getIntlayer: 'getDictionary',\n  useIntlayer: 'useDictionary',\n} as const;\n\nconst DYNAMIC_IMPORT_FUNCTION = {\n  useIntlayer: 'useDictionaryDynamic',\n} as const;\n\n/* ────────────────────────────────────────── types ───────────────────────── */\n\n/**\n * Options for the optimization Babel plugin\n */\nexport type OptimizePluginOptions = {\n  /**\n   * If false, the plugin will not apply any transformation.\n   */\n  optimize?: boolean;\n  /**\n   * The path to the dictionaries directory.\n   */\n  dictionariesDir: string;\n  /**\n   * The path to the dictionaries entry file.\n   */\n  dictionariesEntryPath: string;\n  /**\n   * The path to the unmerged dictionaries entry file.\n   */\n  unmergedDictionariesEntryPath: string;\n  /**\n   * The path to the unmerged dictionaries directory.\n   */\n  unmergedDictionariesDir: string;\n  /**\n   * The path to the dictionaries directory.\n   */\n  dynamicDictionariesDir: string;\n  /**\n   * The path to the dynamic dictionaries entry file.\n   */\n  dynamicDictionariesEntryPath: string;\n  /**\n   * The path to the fetch dictionaries directory.\n   */\n  fetchDictionariesDir: string;\n  /**\n   * The path to the fetch dictionaries entry file.\n   */\n  fetchDictionariesEntryPath: string;\n  /**\n   * If true, the plugin will replace the dictionary entry file with `export default {}`.\n   */\n  replaceDictionaryEntry: boolean;\n  /**\n   * If true, the plugin will activate the dynamic import of the dictionaries. It will rely on Suspense to load the dictionaries.\n   */\n  importMode: 'static' | 'dynamic' | 'live';\n  /**\n   * Activate the live sync of the dictionaries.\n   * If `importMode` is `live`, the plugin will activate the live sync of the dictionaries.\n   */\n  liveSyncKeys: string[];\n  /**\n   * Files list to traverse.\n   */\n  filesList: string[];\n};\n\ntype State = PluginPass & {\n  opts: OptimizePluginOptions;\n  /** map key → generated ident (per-file) for static imports */\n  _newStaticImports?: Map<string, BabelTypes.Identifier>;\n  /** map key → generated ident (per-file) for dynamic imports */\n  _newDynamicImports?: Map<string, BabelTypes.Identifier>;\n  /** whether the current file imported *any* intlayer package */\n  _hasValidImport?: boolean;\n  /** whether the current file *is* the dictionaries entry file */\n  _isDictEntry?: boolean;\n  /** whether dynamic helpers are active for this file */\n  _useDynamicHelpers?: boolean;\n  /** whether the current file is included in the filesList */\n  _isIncluded?: boolean;\n};\n\n/* ────────────────────────────────────────── helpers ─────────────────────── */\n\n/**\n * Replicates the xxHash64 → Base-62 algorithm used by the SWC version\n * and prefixes an underscore so the generated identifiers never collide\n * with user-defined ones.\n */\nconst makeIdent = (\n  key: string,\n  t: typeof BabelTypes\n): BabelTypes.Identifier => {\n  const hash = getFileHash(key);\n  return t.identifier(`_${hash}`);\n};\n\nconst computeImport = (\n  fromFile: string,\n  dictionariesDir: string,\n  dynamicDictionariesDir: string,\n  fetchDictionariesDir: string,\n  key: string,\n  importMode: 'static' | 'dynamic' | 'live'\n): string => {\n  let relativePath = join(dictionariesDir, `${key}.json`);\n\n  if (importMode === 'live') {\n    relativePath = join(fetchDictionariesDir, `${key}.mjs`);\n  }\n\n  if (importMode === 'dynamic') {\n    relativePath = join(dynamicDictionariesDir, `${key}.mjs`);\n  }\n\n  let rel = relative(dirname(fromFile), relativePath);\n\n  // Fix windows path\n  rel = normalizePath(rel);\n\n  // Fix relative path\n  if (!rel.startsWith('./') && !rel.startsWith('../')) {\n    rel = `./${rel}`;\n  }\n\n  return rel;\n};\n\n/* ────────────────────────────────────────── plugin ──────────────────────── */\n\n/**\n * Babel plugin that transforms Intlayer function calls and auto-imports dictionaries.\n *\n * This plugin transforms calls to `useIntlayer()` and `getIntlayer()` from various Intlayer\n * packages into optimized dictionary access patterns, automatically importing the required\n * dictionary files based on the configured import mode.\n *\n * ## Supported Input Patterns\n *\n * The plugin recognizes these function calls:\n *\n * ```ts\n * // useIntlayer\n * import { useIntlayer } from 'react-intlayer';\n * import { useIntlayer } from 'next-intlayer';\n *\n * // getIntlayer\n * import { getIntlayer } from 'intlayer';\n *\n * // Usage\n * const content = useIntlayer('app');\n * const content = getIntlayer('app');\n * ```\n *\n * ## Transformation Modes\n *\n * ### Static Mode (default: `importMode = \"static\"`)\n *\n * Imports JSON dictionaries directly and replaces function calls with dictionary access:\n *\n * **Output:**\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import { useDictionary as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash);\n * const content2 = getIntlayer(_dicHash);\n * ```\n *\n * ### Dynamic Mode (`importMode = \"dynamic\"`)\n *\n * Uses dynamic dictionary loading with Suspense support:\n *\n * **Output:**\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import _dicHash_dyn from '../../.intlayer/dynamic_dictionaries/app.mjs';\n * import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash_dyn, 'app');\n * const content2 = getIntlayer(_dicHash);\n * ```\n *\n * ### Live Mode (`importMode = \"live\"`)\n *\n * Uses live-based dictionary loading for remote dictionaries:\n *\n * **Output if `liveSyncKeys` includes the key:**\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import _dicHash_fetch from '../../.intlayer/fetch_dictionaries/app.mjs';\n * import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash_fetch, \"app\");\n * const content2 = getIntlayer(_dicHash);\n * ```\n *\n * > If `liveSyncKeys` does not include the key, the plugin will fallback to the dynamic impor\n *\n * ```ts\n * import _dicHash from '../../.intlayer/dictionaries/app.json' with { type: 'json' };\n * import _dicHash_dyn from '../../.intlayer/dynamic_dictionaries/app.mjs';\n * import { useDictionaryDynamic as useIntlayer } from 'react-intlayer';\n * import { getDictionary as getIntlayer } from 'intlayer';\n *\n * const content1 = useIntlayer(_dicHash_dyn, 'app');\n * const content2 = getIntlayer(_dicHash);\n * ```\n */\nexport const intlayerOptimizeBabelPlugin = (babel: {\n  types: typeof BabelTypes;\n}): PluginObj<State> => {\n  const { types: t } = babel;\n\n  return {\n    name: 'babel-plugin-intlayer-transform',\n\n    pre() {\n      this._newStaticImports = new Map();\n      this._newDynamicImports = new Map();\n      this._isIncluded = true;\n      this._hasValidImport = false;\n      this._isDictEntry = false;\n      this._useDynamicHelpers = false;\n\n      // If optimize is false, skip processing entirely\n      if (this.opts.optimize === false) {\n        this._isIncluded = false;\n        return;\n      }\n\n      // If filesList is provided, check if current file is included\n      const filename = this.file.opts.filename;\n      if (this.opts.filesList && filename) {\n        const isIncluded = this.opts.filesList.includes(filename);\n\n        if (!isIncluded) {\n          // Force _isIncluded to false to skip processing\n          this._isIncluded = false;\n          return;\n        }\n      }\n    },\n\n    visitor: {\n      /* If this file *is* the dictionaries entry, short-circuit: export {} */\n      Program: {\n        enter(programPath, state) {\n          // Safe access to filename\n          const filename = state.file.opts.filename;\n\n          // Check if this is the correct file to transform\n          if (\n            state.opts.replaceDictionaryEntry &&\n            filename === state.opts.dictionariesEntryPath\n          ) {\n            state._isDictEntry = true;\n\n            // Traverse the program to surgically remove/edit specific parts\n            programPath.traverse({\n              // Remove all import statements (cleaning up 'sssss.json')\n              ImportDeclaration(path) {\n                path.remove();\n              },\n\n              // Find the variable definition and empty the object\n              VariableDeclarator(path) {\n                // We look for: const x = { ... }\n                if (t.isObjectExpression(path.node.init)) {\n                  // Set the object properties to an empty array: {}\n                  path.node.init.properties = [];\n                }\n              },\n            });\n\n            // (Optional) Stop other plugins from processing this file further if needed\n            // programPath.stop();\n          }\n        },\n\n        /**\n         * After full traversal, process imports and call expressions, then inject the JSON dictionary imports.\n         *\n         * We do the transformation in Program.exit (via a manual traverse) rather than using\n         * top-level ImportDeclaration/CallExpression visitors. This ensures that if another plugin\n         * (like babel-plugin-intlayer-extract) adds new useIntlayer calls in its Program.exit,\n         * we will see and transform them here because our Program.exit runs after theirs.\n         */\n        exit(programPath, state) {\n          if (state._isDictEntry) return; // nothing else to do – already replaced\n          if (!state._isIncluded) return; // early-out if file is not included\n\n          // Manual traversal to process imports and call expressions\n          // This runs AFTER all other plugins' visitors have completed\n          programPath.traverse({\n            /* Inspect every intlayer import */\n            ImportDeclaration(path) {\n              const src = path.node.source.value;\n              if (!PACKAGE_LIST.includes(src)) return;\n\n              // Mark that we do import from an intlayer package in this file\n              state._hasValidImport = true;\n\n              for (const spec of path.node.specifiers) {\n                if (!t.isImportSpecifier(spec)) continue;\n\n                // ⚠️  We now key off *imported* name, *not* local name.\n                const importedName = t.isIdentifier(spec.imported)\n                  ? spec.imported.name\n                  : (spec.imported as BabelTypes.StringLiteral).value;\n\n                const importMode = state.opts.importMode;\n                // Determine whether this import should use the dynamic helpers.\n                const shouldUseDynamicHelpers =\n                  (importMode === 'dynamic' || importMode === 'live') &&\n                  PACKAGE_LIST_DYNAMIC.includes(src as any);\n\n                // Remember for later (CallExpression) whether we are using the dynamic helpers\n                if (shouldUseDynamicHelpers) {\n                  state._useDynamicHelpers = true;\n                }\n\n                let helperMap: Record<string, string>;\n\n                if (shouldUseDynamicHelpers) {\n                  // Use dynamic helpers for useIntlayer when dynamic mode is enabled\n                  helperMap = {\n                    ...STATIC_IMPORT_FUNCTION,\n                    ...DYNAMIC_IMPORT_FUNCTION,\n                  } as Record<string, string>;\n                } else {\n                  // Use static helpers by default\n                  helperMap = STATIC_IMPORT_FUNCTION as Record<string, string>;\n                }\n\n                const newIdentifier = helperMap[importedName];\n\n                // Only rewrite when we actually have a mapping for the imported\n                // specifier (ignore unrelated named imports).\n                if (newIdentifier) {\n                  // Keep the local alias intact (so calls remain `useIntlayer` /\n                  // `getIntlayer`), but rewrite the imported identifier so it\n                  // points to our helper implementation.\n                  spec.imported = t.identifier(newIdentifier);\n                }\n              }\n            },\n\n            /* Replace calls: useIntlayer(\"foo\") → useDictionary(_hash) or useDictionaryDynamic(_hash, \"foo\") */\n            CallExpression(path) {\n              const callee = path.node.callee;\n              if (!t.isIdentifier(callee)) return;\n              if (!CALLER_LIST.includes(callee.name as any)) return;\n\n              // Ensure we ultimately emit helper imports for files that *invoke*\n              // the hooks, even if they didn't import them directly (edge cases with\n              // re-exports).\n              state._hasValidImport = true;\n\n              const arg = path.node.arguments[0];\n              if (!arg || !t.isStringLiteral(arg)) return; // must be literal\n\n              const key = arg.value;\n              const importMode = state.opts.importMode;\n              const isUseIntlayer = callee.name === 'useIntlayer';\n              const useDynamicHelpers = Boolean(state._useDynamicHelpers);\n\n              // Decide per-call mode: 'static' | 'dynamic' | 'live'\n              let perCallMode: 'static' | 'dynamic' | 'live' = 'static';\n              if (isUseIntlayer && useDynamicHelpers) {\n                if (importMode === 'dynamic') {\n                  perCallMode = 'dynamic';\n                } else if (importMode === 'live') {\n                  const liveKeys = state.opts.liveSyncKeys ?? [];\n                  perCallMode = liveKeys.includes(key) ? 'live' : 'dynamic';\n                }\n              }\n\n              let ident: BabelTypes.Identifier;\n\n              if (perCallMode === 'live') {\n                // Use fetch dictionaries entry (live mode for selected keys)\n                let dynamicIdent = state._newDynamicImports?.get(key);\n                if (!dynamicIdent) {\n                  const hash = getFileHash(key);\n                  dynamicIdent = t.identifier(`_${hash}_fetch`);\n                  state._newDynamicImports?.set(key, dynamicIdent);\n                }\n                ident = dynamicIdent;\n\n                // Helper: first argument is the dictionary entry, second is the key\n                path.node.arguments = [\n                  t.identifier(ident.name),\n                  ...path.node.arguments,\n                ];\n              } else if (perCallMode === 'dynamic') {\n                // Use dynamic dictionaries entry\n                let dynamicIdent = state._newDynamicImports?.get(key);\n                if (!dynamicIdent) {\n                  // Create a unique identifier for dynamic imports by appending a suffix\n                  const hash = getFileHash(key);\n                  dynamicIdent = t.identifier(`_${hash}_dyn`);\n                  state._newDynamicImports?.set(key, dynamicIdent);\n                }\n                ident = dynamicIdent;\n\n                // Dynamic helper: first argument is the dictionary, second is the key.\n                path.node.arguments = [\n                  t.identifier(ident.name),\n                  ...path.node.arguments,\n                ];\n              } else {\n                // Use static imports for getIntlayer or useIntlayer when not using dynamic helpers\n                let staticIdent = state._newStaticImports?.get(key);\n                if (!staticIdent) {\n                  staticIdent = makeIdent(key, t);\n                  state._newStaticImports?.set(key, staticIdent);\n                }\n                ident = staticIdent;\n\n                // Static helper (useDictionary / getDictionary): replace key with iden\n                path.node.arguments[0] = t.identifier(ident.name);\n              }\n            },\n          });\n\n          // Early-out if we touched nothing\n          if (!state._hasValidImport) return;\n\n          const file = state.file.opts.filename!;\n          const dictionariesDir = state.opts.dictionariesDir;\n          const dynamicDictionariesDir = state.opts.dynamicDictionariesDir;\n          const fetchDictionariesDir = state.opts.fetchDictionariesDir;\n          const imports: BabelTypes.ImportDeclaration[] = [];\n\n          // Generate static JSON imports (getIntlayer always uses JSON dictionaries)\n          for (const [key, ident] of state._newStaticImports!) {\n            const rel = computeImport(\n              file,\n              dictionariesDir,\n              dynamicDictionariesDir,\n              fetchDictionariesDir,\n              key,\n              'static'\n            );\n\n            const importDeclarationNode = t.importDeclaration(\n              [t.importDefaultSpecifier(t.identifier(ident.name))],\n              t.stringLiteral(rel)\n            );\n\n            // Add 'type: json' attribute for JSON files\n            importDeclarationNode.attributes = [\n              t.importAttribute(t.identifier('type'), t.stringLiteral('json')),\n            ];\n\n            imports.push(importDeclarationNode);\n          }\n\n          // Generate dynamic/fetch imports (for useIntlayer when using dynamic/live helpers)\n          for (const [key, ident] of state._newDynamicImports!) {\n            const modeForThisIdent: 'dynamic' | 'live' = ident.name.endsWith(\n              '_fetch'\n            )\n              ? 'live'\n              : 'dynamic';\n\n            const rel = computeImport(\n              file,\n              dictionariesDir,\n              dynamicDictionariesDir,\n              fetchDictionariesDir,\n              key,\n              modeForThisIdent\n            );\n            imports.push(\n              t.importDeclaration(\n                [t.importDefaultSpecifier(t.identifier(ident.name))],\n                t.stringLiteral(rel)\n              )\n            );\n          }\n\n          if (!imports.length) return;\n\n          /* Keep \"use client\" / \"use server\" directives at the very top. */\n          const bodyPaths = programPath.get(\n            'body'\n          ) as NodePath<BabelTypes.Statement>[];\n          let insertPos = 0;\n          for (const stmtPath of bodyPaths) {\n            const stmt = stmtPath.node;\n            if (\n              t.isExpressionStatement(stmt) &&\n              t.isStringLiteral(stmt.expression) &&\n              !stmt.expression.value.startsWith('import') &&\n              !stmt.expression.value.startsWith('require')\n            ) {\n              insertPos += 1;\n            } else {\n              break;\n            }\n          }\n\n          programPath.node.body.splice(insertPos, 0, ...imports);\n        },\n      },\n    },\n  };\n};\n"],"mappings":"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"}

package/dist/esm/getExtractPluginOptions.mjs

@@ -0,0 +1,79 @@
+import { join, relative } from "node:path";
+import { buildDictionary, writeContentDeclaration } from "@intlayer/chokidar";
+import { getConfiguration } from "@intlayer/config";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+
+//#region src/getExtractPluginOptions.ts
+/**
+* Get the options for the Intlayer Babel extraction plugin
+* This function loads the Intlayer configuration and sets up the onExtract callback
+* to write dictionaries to the filesystem.
+*/
+const getExtractPluginOptions = () => {
+	const config = getConfiguration();
+	const { baseDir } = config.content;
+	const compilerDir = join(baseDir, config.compiler?.outputDir ?? "compiler");
+	/**
+	* Read existing dictionary file if it exists
+	*/
+	const readExistingDictionary = async (dictionaryPath) => {
+		try {
+			if (!existsSync(dictionaryPath)) return null;
+			const content = await readFile(dictionaryPath, "utf-8");
+			return JSON.parse(content);
+		} catch {
+			return null;
+		}
+	};
+	/**
+	* Merge extracted content with existing dictionary, preserving translations.
+	* - Keys in extracted but not in existing: added with default locale only
+	* - Keys in both: preserve existing translations, update default locale value
+	* - Keys in existing but not in extracted: removed (no longer in source)
+	*/
+	const mergeWithExistingDictionary = (extractedContent, existingDictionary, defaultLocale) => {
+		const mergedContent = {};
+		const existingContent = existingDictionary?.content;
+		for (const [key, value] of Object.entries(extractedContent)) {
+			const existingEntry = existingContent?.[key];
+			if (existingEntry && existingEntry.nodeType === "translation" && existingEntry.translation) mergedContent[key] = {
+				nodeType: "translation",
+				translation: {
+					...existingEntry.translation,
+					[defaultLocale]: value
+				}
+			};
+			else mergedContent[key] = {
+				nodeType: "translation",
+				translation: { [defaultLocale]: value }
+			};
+		}
+		return mergedContent;
+	};
+	const handleExtractedContent = async (result) => {
+		const { dictionaryKey, content, locale } = result;
+		try {
+			const dictionary = {
+				key: dictionaryKey,
+				content: mergeWithExistingDictionary(content, await readExistingDictionary(join(compilerDir, `${dictionaryKey}.content.json`)), locale),
+				filePath: join(relative(baseDir, compilerDir), `${dictionaryKey}.content.json`)
+			};
+			const writeResult = await writeContentDeclaration(dictionary, config, { newDictionariesPath: relative(baseDir, compilerDir) });
+			await buildDictionary([{
+				...dictionary,
+				filePath: relative(baseDir, writeResult.path)
+			}], config);
+		} catch (error) {
+			console.error(`[intlayer] Failed to process extracted content for ${dictionaryKey}:`, error);
+		}
+	};
+	return {
+		defaultLocale: config.internationalization.defaultLocale,
+		onExtract: handleExtractedContent
+	};
+};
+
+//#endregion
+export { getExtractPluginOptions };
+//# sourceMappingURL=getExtractPluginOptions.mjs.map

package/dist/esm/getExtractPluginOptions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getExtractPluginOptions.mjs","names":["mergedContent: DictionaryContentMap","dictionary: Dictionary"],"sources":["../../src/getExtractPluginOptions.ts"],"sourcesContent":["import { existsSync } from 'node:fs';\nimport { readFile } from 'node:fs/promises';\nimport { join, relative } from 'node:path';\nimport { buildDictionary, writeContentDeclaration } from '@intlayer/chokidar';\nimport { getConfiguration } from '@intlayer/config';\nimport type { Dictionary } from '@intlayer/types';\nimport type {\n  ExtractPluginOptions,\n  ExtractResult,\n} from './babel-plugin-intlayer-extract';\n\n/**\n * Translation node structure used in dictionaries\n */\ntype TranslationNode = {\n  nodeType: 'translation';\n  translation: Record<string, string>;\n};\n\n/**\n * Dictionary content structure - map of keys to translation nodes\n */\ntype DictionaryContentMap = Record<string, TranslationNode>;\n\n/**\n * Get the options for the Intlayer Babel extraction plugin\n * This function loads the Intlayer configuration and sets up the onExtract callback\n * to write dictionaries to the filesystem.\n */\nexport const getExtractPluginOptions = (): ExtractPluginOptions => {\n  const config = getConfiguration();\n  const { baseDir } = config.content;\n  const compilerDir = join(baseDir, config.compiler?.outputDir ?? 'compiler');\n\n  /**\n   * Read existing dictionary file if it exists\n   */\n  const readExistingDictionary = async (\n    dictionaryPath: string\n  ): Promise<Dictionary | null> => {\n    try {\n      if (!existsSync(dictionaryPath)) {\n        return null;\n      }\n      const content = await readFile(dictionaryPath, 'utf-8');\n      return JSON.parse(content) as Dictionary;\n    } catch {\n      return null;\n    }\n  };\n\n  /**\n   * Merge extracted content with existing dictionary, preserving translations.\n   * - Keys in extracted but not in existing: added with default locale only\n   * - Keys in both: preserve existing translations, update default locale value\n   * - Keys in existing but not in extracted: removed (no longer in source)\n   */\n  const mergeWithExistingDictionary = (\n    extractedContent: Record<string, string>,\n    existingDictionary: Dictionary | null,\n    defaultLocale: string\n  ): DictionaryContentMap => {\n    const mergedContent: DictionaryContentMap = {};\n    const existingContent = existingDictionary?.content as\n      | DictionaryContentMap\n      | undefined;\n\n    for (const [key, value] of Object.entries(extractedContent)) {\n      const existingEntry = existingContent?.[key];\n\n      if (\n        existingEntry &&\n        existingEntry.nodeType === 'translation' &&\n        existingEntry.translation\n      ) {\n        // Key exists in both - preserve existing translations, update default locale\n        mergedContent[key] = {\n          nodeType: 'translation',\n          translation: {\n            ...existingEntry.translation,\n            [defaultLocale]: value,\n          },\n        };\n      } else {\n        // New key - add with default locale only\n        mergedContent[key] = {\n          nodeType: 'translation',\n          translation: {\n            [defaultLocale]: value,\n          },\n        };\n      }\n    }\n\n    return mergedContent;\n  };\n\n  const handleExtractedContent = async (result: ExtractResult) => {\n    const { dictionaryKey, content, locale } = result;\n\n    try {\n      const dictionaryPath = join(compilerDir, `${dictionaryKey}.content.json`);\n\n      // Read existing dictionary to preserve translations\n      const existingDictionary = await readExistingDictionary(dictionaryPath);\n\n      // Merge extracted content with existing translations\n      const mergedContent = mergeWithExistingDictionary(\n        content,\n        existingDictionary,\n        locale\n      );\n\n      const dictionary: Dictionary = {\n        key: dictionaryKey,\n        content: mergedContent,\n        filePath: join(\n          relative(baseDir, compilerDir),\n          `${dictionaryKey}.content.json`\n        ),\n      };\n\n      const writeResult = await writeContentDeclaration(dictionary, config, {\n        newDictionariesPath: relative(baseDir, compilerDir),\n      });\n\n      // Build the dictionary immediately\n      const dictionaryToBuild: Dictionary = {\n        ...dictionary,\n        filePath: relative(baseDir, writeResult.path),\n      };\n\n      await buildDictionary([dictionaryToBuild], config);\n    } catch (error) {\n      console.error(\n        `[intlayer] Failed to process extracted content for ${dictionaryKey}:`,\n        error\n      );\n    }\n  };\n\n  return {\n    defaultLocale: config.internationalization.defaultLocale,\n    // filesList can be passed if needed, but usually handled by include/exclude in build tool\n    onExtract: handleExtractedContent,\n  };\n};\n"],"mappings":";;;;;;;;;;;;AA6BA,MAAa,gCAAsD;CACjE,MAAM,SAAS,kBAAkB;CACjC,MAAM,EAAE,YAAY,OAAO;CAC3B,MAAM,cAAc,KAAK,SAAS,OAAO,UAAU,aAAa,WAAW;;;;CAK3E,MAAM,yBAAyB,OAC7B,mBAC+B;AAC/B,MAAI;AACF,OAAI,CAAC,WAAW,eAAe,CAC7B,QAAO;GAET,MAAM,UAAU,MAAM,SAAS,gBAAgB,QAAQ;AACvD,UAAO,KAAK,MAAM,QAAQ;UACpB;AACN,UAAO;;;;;;;;;CAUX,MAAM,+BACJ,kBACA,oBACA,kBACyB;EACzB,MAAMA,gBAAsC,EAAE;EAC9C,MAAM,kBAAkB,oBAAoB;AAI5C,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,iBAAiB,EAAE;GAC3D,MAAM,gBAAgB,kBAAkB;AAExC,OACE,iBACA,cAAc,aAAa,iBAC3B,cAAc,YAGd,eAAc,OAAO;IACnB,UAAU;IACV,aAAa;KACX,GAAG,cAAc;MAChB,gBAAgB;KAClB;IACF;OAGD,eAAc,OAAO;IACnB,UAAU;IACV,aAAa,GACV,gBAAgB,OAClB;IACF;;AAIL,SAAO;;CAGT,MAAM,yBAAyB,OAAO,WAA0B;EAC9D,MAAM,EAAE,eAAe,SAAS,WAAW;AAE3C,MAAI;GAaF,MAAMC,aAAyB;IAC7B,KAAK;IACL,SARoB,4BACpB,SAJyB,MAAM,uBAHV,KAAK,aAAa,GAAG,cAAc,eAAe,CAGF,EAMrE,OACD;IAKC,UAAU,KACR,SAAS,SAAS,YAAY,EAC9B,GAAG,cAAc,eAClB;IACF;GAED,MAAM,cAAc,MAAM,wBAAwB,YAAY,QAAQ,EACpE,qBAAqB,SAAS,SAAS,YAAY,EACpD,CAAC;AAQF,SAAM,gBAAgB,CALgB;IACpC,GAAG;IACH,UAAU,SAAS,SAAS,YAAY,KAAK;IAC9C,CAEwC,EAAE,OAAO;WAC3C,OAAO;AACd,WAAQ,MACN,sDAAsD,cAAc,IACpE,MACD;;;AAIL,QAAO;EACL,eAAe,OAAO,qBAAqB;EAE3C,WAAW;EACZ"}

package/dist/esm/getOptimizePluginOptions.mjs

@@ -0,0 +1,59 @@
+import { __require } from "./_virtual/rolldown_runtime.mjs";
+import { join } from "node:path";
+import { getConfiguration } from "@intlayer/config";
+import fg from "fast-glob";
+
+//#region src/getOptimizePluginOptions.ts
+/**
+* Load dictionaries from the dictionaries-entry package
+*/
+const loadDictionaries = (config) => {
+	try {
+		const { getDictionaries } = __require("@intlayer/dictionaries-entry");
+		const dictionariesRecord = getDictionaries(config);
+		return Object.values(dictionariesRecord);
+	} catch {
+		return [];
+	}
+};
+/**
+* Get the options for the Intlayer Babel optimization plugin
+* This function loads the Intlayer configuration and returns the paths
+* needed for dictionary optimization and import rewriting.
+*/
+const getOptimizePluginOptions = (params) => {
+	const { configOptions, dictionaries: providedDictionaries, overrides } = params ?? {};
+	const config = getConfiguration(configOptions);
+	const { mainDir, baseDir, dictionariesDir, unmergedDictionariesDir, dynamicDictionariesDir, fetchDictionariesDir } = config.content;
+	const { importMode, traversePattern, optimize } = config.build;
+	const filesListPattern = fg.sync(traversePattern, { cwd: baseDir }).map((file) => join(baseDir, file));
+	const dictionariesEntryPath = join(mainDir, "dictionaries.mjs");
+	const unmergedDictionariesEntryPath = join(mainDir, "unmerged_dictionaries.mjs");
+	const dynamicDictionariesEntryPath = join(mainDir, "dynamic_dictionaries.mjs");
+	const fetchDictionariesEntryPath = join(mainDir, "fetch_dictionaries.mjs");
+	const filesList = [
+		...filesListPattern,
+		dictionariesEntryPath,
+		unmergedDictionariesEntryPath
+	];
+	return {
+		optimize,
+		dictionariesDir,
+		dictionariesEntryPath,
+		unmergedDictionariesDir,
+		unmergedDictionariesEntryPath,
+		dynamicDictionariesDir,
+		dynamicDictionariesEntryPath,
+		fetchDictionariesDir,
+		fetchDictionariesEntryPath,
+		replaceDictionaryEntry: true,
+		importMode,
+		liveSyncKeys: (providedDictionaries ?? loadDictionaries(config)).filter((dictionary) => dictionary.live).map((dictionary) => dictionary.key),
+		filesList,
+		...overrides
+	};
+};
+
+//#endregion
+export { getOptimizePluginOptions };
+//# sourceMappingURL=getOptimizePluginOptions.mjs.map

package/dist/esm/getOptimizePluginOptions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOptimizePluginOptions.mjs","names":[],"sources":["../../src/getOptimizePluginOptions.ts"],"sourcesContent":["import { join } from 'node:path';\nimport {\n  type GetConfigurationOptions,\n  getConfiguration,\n} from '@intlayer/config';\nimport type { Dictionary, IntlayerConfig } from '@intlayer/types';\nimport fg from 'fast-glob';\nimport type { OptimizePluginOptions } from './babel-plugin-intlayer-optimize';\n\ntype GetOptimizePluginOptionsParams = {\n  /**\n   * Configuration options for loading intlayer config\n   */\n  configOptions?: GetConfigurationOptions;\n  /**\n   * Pre-loaded dictionaries (optional - will be loaded if not provided)\n   */\n  dictionaries?: Dictionary[];\n  /**\n   * Override specific options\n   */\n  overrides?: Partial<OptimizePluginOptions>;\n};\n\n/**\n * Load dictionaries from the dictionaries-entry package\n */\nconst loadDictionaries = (config: IntlayerConfig): Dictionary[] => {\n  try {\n    // Dynamic require to avoid build-time dependency issues\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    const { getDictionaries } = require('@intlayer/dictionaries-entry');\n    const dictionariesRecord = getDictionaries(config) as Record<\n      string,\n      Dictionary\n    >;\n    return Object.values(dictionariesRecord);\n  } catch {\n    // If dictionaries-entry is not available, return empty array\n    return [];\n  }\n};\n\n/**\n * Get the options for the Intlayer Babel optimization plugin\n * This function loads the Intlayer configuration and returns the paths\n * needed for dictionary optimization and import rewriting.\n */\nexport const getOptimizePluginOptions = (\n  params?: GetOptimizePluginOptionsParams\n): OptimizePluginOptions => {\n  const {\n    configOptions,\n    dictionaries: providedDictionaries,\n    overrides,\n  } = params ?? {};\n\n  const config = getConfiguration(configOptions);\n  const {\n    mainDir,\n    baseDir,\n    dictionariesDir,\n    unmergedDictionariesDir,\n    dynamicDictionariesDir,\n    fetchDictionariesDir,\n  } = config.content;\n  const { importMode, traversePattern, optimize } = config.build;\n\n  // Build files list from traverse pattern\n  const filesListPattern = fg\n    .sync(traversePattern, {\n      cwd: baseDir,\n    })\n    .map((file) => join(baseDir, file));\n\n  const dictionariesEntryPath = join(mainDir, 'dictionaries.mjs');\n  const unmergedDictionariesEntryPath = join(\n    mainDir,\n    'unmerged_dictionaries.mjs'\n  );\n  const dynamicDictionariesEntryPath = join(\n    mainDir,\n    'dynamic_dictionaries.mjs'\n  );\n  const fetchDictionariesEntryPath = join(mainDir, 'fetch_dictionaries.mjs');\n\n  const filesList = [\n    ...filesListPattern,\n    dictionariesEntryPath, // should add dictionariesEntryPath to replace it by an empty object if import made dynamic\n    unmergedDictionariesEntryPath, // should add dictionariesEntryPath to replace it by an empty object if import made dynamic\n  ];\n\n  // Load dictionaries if not provided\n  const dictionaries = providedDictionaries ?? loadDictionaries(config);\n\n  const liveSyncKeys = dictionaries\n    .filter((dictionary) => dictionary.live)\n    .map((dictionary) => dictionary.key);\n\n  return {\n    optimize,\n    dictionariesDir,\n    dictionariesEntryPath,\n    unmergedDictionariesDir,\n    unmergedDictionariesEntryPath,\n    dynamicDictionariesDir,\n    dynamicDictionariesEntryPath,\n    fetchDictionariesDir,\n    fetchDictionariesEntryPath,\n    replaceDictionaryEntry: true,\n    importMode,\n    liveSyncKeys,\n    filesList,\n    ...overrides,\n  };\n};\n"],"mappings":";;;;;;;;;AA2BA,MAAM,oBAAoB,WAAyC;AACjE,KAAI;EAGF,MAAM,EAAE,8BAA4B,+BAA+B;EACnE,MAAM,qBAAqB,gBAAgB,OAAO;AAIlD,SAAO,OAAO,OAAO,mBAAmB;SAClC;AAEN,SAAO,EAAE;;;;;;;;AASb,MAAa,4BACX,WAC0B;CAC1B,MAAM,EACJ,eACA,cAAc,sBACd,cACE,UAAU,EAAE;CAEhB,MAAM,SAAS,iBAAiB,cAAc;CAC9C,MAAM,EACJ,SACA,SACA,iBACA,yBACA,wBACA,yBACE,OAAO;CACX,MAAM,EAAE,YAAY,iBAAiB,aAAa,OAAO;CAGzD,MAAM,mBAAmB,GACtB,KAAK,iBAAiB,EACrB,KAAK,SACN,CAAC,CACD,KAAK,SAAS,KAAK,SAAS,KAAK,CAAC;CAErC,MAAM,wBAAwB,KAAK,SAAS,mBAAmB;CAC/D,MAAM,gCAAgC,KACpC,SACA,4BACD;CACD,MAAM,+BAA+B,KACnC,SACA,2BACD;CACD,MAAM,6BAA6B,KAAK,SAAS,yBAAyB;CAE1E,MAAM,YAAY;EAChB,GAAG;EACH;EACA;EACD;AASD,QAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,wBAAwB;EACxB;EACA,eAlBmB,wBAAwB,iBAAiB,OAAO,EAGlE,QAAQ,eAAe,WAAW,KAAK,CACvC,KAAK,eAAe,WAAW,IAAI;EAepC;EACA,GAAG;EACJ"}

package/dist/esm/index.mjs

@@ -1,3 +1,6 @@
-import { intlayerBabelPlugin } from "./babel-plugin-intlayer.mjs";
+import { intlayerExtractBabelPlugin } from "./babel-plugin-intlayer-extract.mjs";
+import { intlayerOptimizeBabelPlugin } from "./babel-plugin-intlayer-optimize.mjs";
+import { getExtractPluginOptions } from "./getExtractPluginOptions.mjs";
+import { getOptimizePluginOptions } from "./getOptimizePluginOptions.mjs";
 
-export { intlayerBabelPlugin };
+export { getExtractPluginOptions, getOptimizePluginOptions, intlayerExtractBabelPlugin, intlayerOptimizeBabelPlugin };

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

@@ -0,0 +1,133 @@
+import { PluginObj, PluginPass } from "@babel/core";
+import * as BabelTypes from "@babel/types";
+
+//#region src/babel-plugin-intlayer-extract.d.ts
+type ExtractedContent = Record<string, string>;
+/**
+ * Extracted content result from a file transformation
+ */
+type ExtractResult = {
+  /** Dictionary key derived from the file path */
+  dictionaryKey: string;
+  /** File path that was processed */
+  filePath: string;
+  /** Extracted content key-value pairs */
+  content: ExtractedContent;
+  /** Default locale used */
+  locale: string;
+};
+/**
+ * Options for the extraction Babel plugin
+ */
+type ExtractPluginOptions = {
+  /**
+   * The default locale for the extracted content
+   */
+  defaultLocale?: string;
+  /**
+   * The package to import useIntlayer from
+   * @default 'react-intlayer'
+   */
+  packageName?: string;
+  /**
+   * Files list to traverse. If provided, only files in this list will be processed.
+   */
+  filesList?: string[];
+  /**
+   * Custom function to determine if a string should be extracted
+   */
+  shouldExtract?: (text: string) => boolean;
+  /**
+   * Callback function called when content is extracted from a file.
+   * This allows the compiler to capture the extracted content and write it to files.
+   * The dictionary will be updated: new keys added, unused keys removed.
+   */
+  onExtract?: (result: ExtractResult) => void;
+};
+type State = PluginPass & {
+  opts: ExtractPluginOptions;
+  /** Extracted content from this file */
+  _extractedContent?: ExtractedContent;
+  /** Set of existing keys to avoid duplicates */
+  _existingKeys?: Set<string>;
+  /** The dictionary key for this file */
+  _dictionaryKey?: string;
+  /** whether the current file is included in the filesList */
+  _isIncluded?: boolean;
+  /** Whether this file has JSX (React component) */
+  _hasJSX?: boolean;
+  /** Whether we already have useIntlayer imported */
+  _hasUseIntlayerImport?: boolean;
+  /** The local name for useIntlayer (in case it's aliased) */
+  _useIntlayerLocalName?: string;
+  /** The variable name to use for content (content or _compContent if content is already used) */
+  _contentVarName?: string;
+  /** Set of function start positions that have extracted content (only inject hooks into these) */
+  _functionsWithExtractedContent?: Set<number>;
+};
+/**
+ * Autonomous Babel plugin that extracts content and transforms JSX to use useIntlayer.
+ *
+ * This plugin:
+ * 1. Scans files for extractable text (JSX text, attributes)
+ * 2. Auto-injects useIntlayer import and hook call
+ * 3. Reports extracted content via onExtract callback (for the compiler to write dictionaries)
+ * 4. Replaces extractable strings with content references
+ *
+ * ## Input
+ * ```tsx
+ * export const MyComponent = () => {
+ *   return <div>Hello World</div>;
+ * };
+ * ```
+ *
+ * ## Output
+ * ```tsx
+ * import { useIntlayer } from 'react-intlayer';
+ *
+ * export const MyComponent = () => {
+ *   const content = useIntlayer('comp-my-component');
+ *   return <div>{content.helloWorld}</div>;
+ * };
+ * ```
+ *
+ * ## When useIntlayer is already present
+ *
+ * If the component already has a `content` variable from an existing `useIntlayer` call,
+ * the plugin will use `_compContent` to avoid naming conflicts:
+ *
+ * ### Input
+ * ```tsx
+ * export const Page = () => {
+ *   const content = useIntlayer('page');
+ *   return <div>{content.title} - Hello World</div>;
+ * };
+ * ```
+ *
+ * ### Output
+ * ```tsx
+ * export const Page = () => {
+ *   const _compContent = useIntlayer('comp-page');
+ *   const content = useIntlayer('page');
+ *   return <div>{content.title} - {_compContent.helloWorld}</div>;
+ * };
+ * ```
+ *
+ * The extracted content is reported via the `onExtract` callback, allowing the
+ * compiler to write the dictionary to disk separately:
+ * ```json
+ * // my-component.content.json (written by compiler)
+ * {
+ *   "key": "comp-my-component",
+ *   "content": {
+ *     "helloWorld": { "nodeType": "translation", "translation": { "en": "Hello World" } }
+ *   }
+ * }
+ * ```
+ */
+declare const intlayerExtractBabelPlugin: (babel: {
+  types: typeof BabelTypes;
+}) => PluginObj<State>;
+//#endregion
+export { ExtractPluginOptions, ExtractResult, intlayerExtractBabelPlugin };
+//# sourceMappingURL=babel-plugin-intlayer-extract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-intlayer-extract.d.ts","names":[],"sources":["../../src/babel-plugin-intlayer-extract.ts"],"sourcesContent":[],"mappings":";;;;KASK,gBAAA,GAAmB;;AAPwB;AAYhD;AAcY,KAdA,aAAA,GAcoB;EA0B3B;EAAQ,aAAA,EAAA,MAAA;EACL;EAEc,QAAA,EAAA,MAAA;EAEJ;EAciB,OAAA,EArDxB,gBAqDwB;EAAG;EAuFzB,MAAA,EAAA,MAAA;CACG;;;;KArIJ,oBAAA;;;;;;;;;;;;;;;;;;;;;;;uBAuBW;;KAGlB,KAAA,GAAQ;QACL;;sBAEc;;kBAEJ;;;;;;;;;;;;;;mCAciB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuFtB;gBACG;MACZ,UAAU"}