@intlayer/babel 7.3.1 → 7.3.2-canary.1

package/README.md

@@ -24,8 +24,6 @@
   <a href="https://github.com/aymericzip/intlayer/blob/main/LICENSE" target="_blank" rel="noopener noreferrer nofollow"><img src="https://img.shields.io/github/license/aymericzip/intlayer?style=for-the-badge&labelColor=000000&color=FFFFFF&logoColor=000000&cacheSeconds=86400" alt="license"/></a>
   <a href="https://github.com/aymericzip/intlayer/commits/main" target="_blank" rel="noopener noreferrer nofollow"><img src="https://img.shields.io/github/last-commit/aymericzip/intlayer?style=for-the-badge&labelColor=000000&color=FFFFFF&logoColor=000000&cacheSeconds=86400" alt="last commit"/>
   </a>
-  <a href="https://bountyhub.dev/bounties?repo=intlayer" target="_blank" rel="noopener noreferrer nofollow"><img src="https://img.shields.io/badge/Bounties-on%20BountyHub-yellow?style=for-the-badge&labelColor=000000&color=FFFFFF&logoColor=000000&cacheSeconds=86400" alt="Bounties on BountyHub"/>
-  </a>
 </p>
 
 ![Watch the video](https://github.com/aymericzip/intlayer/blob/main/docs/assets/demo_video.gif)

package/dist/cjs/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,29 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

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

@@ -0,0 +1,242 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let node_path = require("node:path");
+let __intlayer_chokidar = require("@intlayer/chokidar");
+
+//#region src/babel-plugin-intlayer-extract.ts
+/**
+* Extract dictionary key from file path
+*/
+const extractDictionaryKeyFromPath = (filePath) => {
+	let baseName = (0, node_path.basename)(filePath, (0, node_path.extname)(filePath));
+	if (baseName === "index") baseName = (0, node_path.basename)((0, node_path.dirname)(filePath));
+	return `comp-${baseName.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase()}`;
+};
+/**
+* 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" } }
+*   }
+* }
+* ```
+*/
+const intlayerExtractBabelPlugin = (babel) => {
+	const { types: t } = babel;
+	return {
+		name: "babel-plugin-intlayer-extract",
+		pre() {
+			this._extractedContent = {};
+			this._existingKeys = /* @__PURE__ */ new Set();
+			this._functionsWithExtractedContent = /* @__PURE__ */ new Set();
+			this._isIncluded = true;
+			this._hasJSX = false;
+			this._hasUseIntlayerImport = false;
+			this._useIntlayerLocalName = "useIntlayer";
+			this._contentVarName = "content";
+			const filename = this.file.opts.filename;
+			if (this.opts.filesList && filename) {
+				const normalizedFilename = filename.replace(/\\/g, "/");
+				if (!this.opts.filesList.some((f) => {
+					return f.replace(/\\/g, "/") === normalizedFilename;
+				})) {
+					this._isIncluded = false;
+					return;
+				}
+			}
+			if (filename) this._dictionaryKey = extractDictionaryKeyFromPath(filename);
+		},
+		visitor: {
+			ImportDeclaration(path, state) {
+				if (!state._isIncluded) return;
+				for (const spec of path.node.specifiers) {
+					if (!t.isImportSpecifier(spec)) continue;
+					if ((t.isIdentifier(spec.imported) ? spec.imported.name : spec.imported.value) === "useIntlayer") {
+						state._hasUseIntlayerImport = true;
+						state._useIntlayerLocalName = spec.local.name;
+					}
+				}
+			},
+			JSXElement(_path, state) {
+				if (!state._isIncluded) return;
+				state._hasJSX = true;
+			},
+			JSXText(path, state) {
+				if (!state._isIncluded) return;
+				const text = path.node.value;
+				if ((state.opts.shouldExtract ?? __intlayer_chokidar.shouldExtract)(text)) {
+					const key = (0, __intlayer_chokidar.generateKey)(text, state._existingKeys);
+					state._existingKeys.add(key);
+					state._extractedContent[key] = text.replace(/\s+/g, " ").trim();
+					const funcParent = path.getFunctionParent();
+					if (funcParent?.node.start != null) state._functionsWithExtractedContent.add(funcParent.node.start);
+					path.replaceWith(t.jsxExpressionContainer(t.memberExpression(t.identifier(state._contentVarName), t.identifier(key), false)));
+				}
+			},
+			JSXAttribute(path, state) {
+				if (!state._isIncluded) return;
+				const name = path.node.name;
+				if (!t.isJSXIdentifier(name)) return;
+				const attrName = name.name;
+				if (!__intlayer_chokidar.ATTRIBUTES_TO_EXTRACT.includes(attrName)) return;
+				const value = path.node.value;
+				let text = null;
+				if (t.isStringLiteral(value)) text = value.value;
+				else if (t.isJSXExpressionContainer(value) && t.isStringLiteral(value.expression)) text = value.expression.value;
+				if (text === null) return;
+				if ((state.opts.shouldExtract ?? __intlayer_chokidar.shouldExtract)(text)) {
+					const key = (0, __intlayer_chokidar.generateKey)(text, state._existingKeys);
+					state._existingKeys.add(key);
+					state._extractedContent[key] = text.trim();
+					const funcParent = path.getFunctionParent();
+					if (funcParent?.node.start != null) state._functionsWithExtractedContent.add(funcParent.node.start);
+					path.node.value = t.jsxExpressionContainer(t.memberExpression(t.memberExpression(t.identifier(state._contentVarName), t.identifier(key), false), t.identifier("value"), false));
+				}
+			},
+			Program: {
+				enter(programPath, state) {
+					if (!state._isIncluded) return;
+					let contentVarUsed = false;
+					programPath.traverse({ VariableDeclarator(varPath) {
+						if (t.isIdentifier(varPath.node.id) && varPath.node.id.name === "content") contentVarUsed = true;
+					} });
+					state._contentVarName = contentVarUsed ? "_compContent" : "content";
+				},
+				exit(programPath, state) {
+					if (!state._isIncluded) return;
+					const hasExtractedContent = Object.keys(state._extractedContent).length > 0;
+					if (!hasExtractedContent) return;
+					if (!state._hasJSX) return;
+					const defaultLocale = state.opts.defaultLocale;
+					const packageName = state.opts.packageName;
+					if (state.opts.onExtract && state._dictionaryKey && hasExtractedContent) state.opts.onExtract({
+						dictionaryKey: state._dictionaryKey,
+						filePath: state.file.opts.filename,
+						content: { ...state._extractedContent },
+						locale: defaultLocale
+					});
+					const bodyPaths = programPath.get("body");
+					if (!state._hasUseIntlayerImport) {
+						const importDeclaration = t.importDeclaration([t.importSpecifier(t.identifier("useIntlayer"), t.identifier("useIntlayer"))], t.stringLiteral(packageName));
+						let importInsertPos = 0;
+						for (const stmtPath of bodyPaths) {
+							const stmt = stmtPath.node;
+							if (t.isExpressionStatement(stmt) && t.isStringLiteral(stmt.expression)) {
+								importInsertPos += 1;
+								continue;
+							}
+							break;
+						}
+						programPath.node.body.splice(importInsertPos, 0, importDeclaration);
+					}
+					const functionsWithContent = state._functionsWithExtractedContent;
+					programPath.traverse({
+						FunctionDeclaration(funcPath) {
+							if (funcPath.node.start != null && functionsWithContent.has(funcPath.node.start)) injectHookIntoFunction(funcPath, state, t);
+						},
+						VariableDeclarator(varPath) {
+							const init = varPath.node.init;
+							if (t.isArrowFunctionExpression(init) || t.isFunctionExpression(init)) {
+								if (init.start != null && functionsWithContent.has(init.start)) injectHookIntoArrowOrExpression(varPath, init, state, t);
+							}
+						}
+					});
+				}
+			}
+		}
+	};
+};
+/**
+* Inject useIntlayer hook into a function declaration
+*/
+const injectHookIntoFunction = (funcPath, state, t) => {
+	const body = funcPath.node.body;
+	if (!t.isBlockStatement(body)) return;
+	let returnsJSX = false;
+	funcPath.traverse({ ReturnStatement(returnPath) {
+		const arg = returnPath.node.argument;
+		if (t.isJSXElement(arg) || t.isJSXFragment(arg)) returnsJSX = true;
+	} });
+	if (!returnsJSX) return;
+	const contentVarName = state._contentVarName;
+	if (body.body.some((stmt) => t.isVariableDeclaration(stmt) && stmt.declarations.some((decl) => t.isIdentifier(decl.id) && decl.id.name === contentVarName && t.isCallExpression(decl.init) && t.isIdentifier(decl.init.callee) && decl.init.callee.name === state._useIntlayerLocalName))) return;
+	const hookCall = t.variableDeclaration("const", [t.variableDeclarator(t.identifier(contentVarName), t.callExpression(t.identifier(state._useIntlayerLocalName), [t.stringLiteral(state._dictionaryKey)]))]);
+	body.body.unshift(hookCall);
+};
+/**
+* Inject useIntlayer hook into an arrow function or function expression
+*/
+const injectHookIntoArrowOrExpression = (varPath, init, state, t) => {
+	const body = init.body;
+	const contentVarName = state._contentVarName;
+	if (t.isJSXElement(body) || t.isJSXFragment(body)) {
+		const hookCall$1 = t.variableDeclaration("const", [t.variableDeclarator(t.identifier(contentVarName), t.callExpression(t.identifier(state._useIntlayerLocalName), [t.stringLiteral(state._dictionaryKey)]))]);
+		const returnStmt = t.returnStatement(body);
+		init.body = t.blockStatement([hookCall$1, returnStmt]);
+		return;
+	}
+	if (!t.isBlockStatement(body)) return;
+	let returnsJSX = false;
+	varPath.traverse({ ReturnStatement(returnPath) {
+		const arg = returnPath.node.argument;
+		if (t.isJSXElement(arg) || t.isJSXFragment(arg)) returnsJSX = true;
+	} });
+	if (!returnsJSX) return;
+	if (body.body.some((stmt) => t.isVariableDeclaration(stmt) && stmt.declarations.some((decl) => t.isIdentifier(decl.id) && decl.id.name === contentVarName && t.isCallExpression(decl.init) && t.isIdentifier(decl.init.callee) && decl.init.callee.name === state._useIntlayerLocalName))) return;
+	const hookCall = t.variableDeclaration("const", [t.variableDeclarator(t.identifier(contentVarName), t.callExpression(t.identifier(state._useIntlayerLocalName), [t.stringLiteral(state._dictionaryKey)]))]);
+	body.body.unshift(hookCall);
+};
+
+//#endregion
+exports.intlayerExtractBabelPlugin = intlayerExtractBabelPlugin;
+//# sourceMappingURL=babel-plugin-intlayer-extract.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin-intlayer-extract.cjs","names":["defaultShouldExtract","ATTRIBUTES_TO_EXTRACT","text: string | null","hookCall"],"sources":["../../src/babel-plugin-intlayer-extract.ts"],"sourcesContent":["import { basename, dirname, extname } from 'node:path';\nimport type { NodePath, PluginObj, PluginPass } from '@babel/core';\nimport type * as BabelTypes from '@babel/types';\nimport {\n  ATTRIBUTES_TO_EXTRACT,\n  shouldExtract as defaultShouldExtract,\n  generateKey,\n} from '@intlayer/chokidar';\n\ntype ExtractedContent = Record<string, string>;\n\n/**\n * Extracted content result from a file transformation\n */\nexport type ExtractResult = {\n  /** Dictionary key derived from the file path */\n  dictionaryKey: string;\n  /** File path that was processed */\n  filePath: string;\n  /** Extracted content key-value pairs */\n  content: ExtractedContent;\n  /** Default locale used */\n  locale: string;\n};\n\n/**\n * Options for the extraction Babel plugin\n */\nexport type ExtractPluginOptions = {\n  /**\n   * The default locale for the extracted content\n   */\n  defaultLocale?: string;\n  /**\n   * The package to import useIntlayer from\n   * @default 'react-intlayer'\n   */\n  packageName?: string;\n  /**\n   * Files list to traverse. If provided, only files in this list will be processed.\n   */\n  filesList?: string[];\n  /**\n   * Custom function to determine if a string should be extracted\n   */\n  shouldExtract?: (text: string) => boolean;\n  /**\n   * Callback function called when content is extracted from a file.\n   * This allows the compiler to capture the extracted content and write it to files.\n   * The dictionary will be updated: new keys added, unused keys removed.\n   */\n  onExtract?: (result: ExtractResult) => void;\n};\n\ntype State = PluginPass & {\n  opts: ExtractPluginOptions;\n  /** Extracted content from this file */\n  _extractedContent?: ExtractedContent;\n  /** Set of existing keys to avoid duplicates */\n  _existingKeys?: Set<string>;\n  /** The dictionary key for this file */\n  _dictionaryKey?: string;\n  /** whether the current file is included in the filesList */\n  _isIncluded?: boolean;\n  /** Whether this file has JSX (React component) */\n  _hasJSX?: boolean;\n  /** Whether we already have useIntlayer imported */\n  _hasUseIntlayerImport?: boolean;\n  /** The local name for useIntlayer (in case it's aliased) */\n  _useIntlayerLocalName?: string;\n  /** The variable name to use for content (content or _compContent if content is already used) */\n  _contentVarName?: string;\n  /** Set of function start positions that have extracted content (only inject hooks into these) */\n  _functionsWithExtractedContent?: Set<number>;\n};\n\n/* ────────────────────────────────────────── helpers ─────────────────────── */\n\n/**\n * Extract dictionary key from file path\n */\nconst extractDictionaryKeyFromPath = (filePath: string): string => {\n  const ext = extname(filePath);\n  let baseName = basename(filePath, ext);\n\n  if (baseName === 'index') {\n    baseName = basename(dirname(filePath));\n  }\n\n  // Convert to kebab-case\n  const key = baseName\n    .replace(/([a-z])([A-Z])/g, '$1-$2')\n    .replace(/[\\s_]+/g, '-')\n    .toLowerCase();\n\n  return `comp-${key}`;\n};\n\n/* ────────────────────────────────────────── plugin ──────────────────────── */\n\n/**\n * Autonomous Babel plugin that extracts content and transforms JSX to use useIntlayer.\n *\n * This plugin:\n * 1. Scans files for extractable text (JSX text, attributes)\n * 2. Auto-injects useIntlayer import and hook call\n * 3. Reports extracted content via onExtract callback (for the compiler to write dictionaries)\n * 4. Replaces extractable strings with content references\n *\n * ## Input\n * ```tsx\n * export const MyComponent = () => {\n *   return <div>Hello World</div>;\n * };\n * ```\n *\n * ## Output\n * ```tsx\n * import { useIntlayer } from 'react-intlayer';\n *\n * export const MyComponent = () => {\n *   const content = useIntlayer('comp-my-component');\n *   return <div>{content.helloWorld}</div>;\n * };\n * ```\n *\n * ## When useIntlayer is already present\n *\n * If the component already has a `content` variable from an existing `useIntlayer` call,\n * the plugin will use `_compContent` to avoid naming conflicts:\n *\n * ### Input\n * ```tsx\n * export const Page = () => {\n *   const content = useIntlayer('page');\n *   return <div>{content.title} - Hello World</div>;\n * };\n * ```\n *\n * ### Output\n * ```tsx\n * export const Page = () => {\n *   const _compContent = useIntlayer('comp-page');\n *   const content = useIntlayer('page');\n *   return <div>{content.title} - {_compContent.helloWorld}</div>;\n * };\n * ```\n *\n * The extracted content is reported via the `onExtract` callback, allowing the\n * compiler to write the dictionary to disk separately:\n * ```json\n * // my-component.content.json (written by compiler)\n * {\n *   \"key\": \"comp-my-component\",\n *   \"content\": {\n *     \"helloWorld\": { \"nodeType\": \"translation\", \"translation\": { \"en\": \"Hello World\" } }\n *   }\n * }\n * ```\n */\nexport const intlayerExtractBabelPlugin = (babel: {\n  types: typeof BabelTypes;\n}): PluginObj<State> => {\n  const { types: t } = babel;\n\n  return {\n    name: 'babel-plugin-intlayer-extract',\n\n    pre() {\n      this._extractedContent = {};\n      this._existingKeys = new Set();\n      this._functionsWithExtractedContent = new Set();\n      this._isIncluded = true;\n      this._hasJSX = false;\n      this._hasUseIntlayerImport = false;\n      this._useIntlayerLocalName = 'useIntlayer';\n      this._contentVarName = 'content'; // Will be updated in Program.enter if 'content' is already used\n\n      const filename = this.file.opts.filename;\n\n      // If filesList is provided, check if current file is included\n      if (this.opts.filesList && filename) {\n        // Normalize paths for comparison (handle potential path separator issues)\n        const normalizedFilename = filename.replace(/\\\\/g, '/');\n        const isIncluded = this.opts.filesList.some((f) => {\n          const normalizedF = f.replace(/\\\\/g, '/');\n          return normalizedF === normalizedFilename;\n        });\n\n        if (!isIncluded) {\n          this._isIncluded = false;\n          return;\n        }\n      }\n\n      // Extract dictionary key from filename\n      if (filename) {\n        this._dictionaryKey = extractDictionaryKeyFromPath(filename);\n      }\n    },\n\n    visitor: {\n      /* Check if useIntlayer is already imported */\n      ImportDeclaration(path, state) {\n        if (!state._isIncluded) return;\n\n        for (const spec of path.node.specifiers) {\n          if (!t.isImportSpecifier(spec)) continue;\n\n          const importedName = t.isIdentifier(spec.imported)\n            ? spec.imported.name\n            : (spec.imported as BabelTypes.StringLiteral).value;\n\n          if (importedName === 'useIntlayer') {\n            state._hasUseIntlayerImport = true;\n            state._useIntlayerLocalName = spec.local.name;\n          }\n        }\n      },\n\n      /* Detect JSX elements to know this is a component file */\n      JSXElement(_path, state) {\n        if (!state._isIncluded) return;\n        state._hasJSX = true;\n      },\n\n      /* Extract JSX text content */\n      JSXText(path, state) {\n        if (!state._isIncluded) return;\n\n        const text = path.node.value;\n        const shouldExtract = state.opts.shouldExtract ?? defaultShouldExtract;\n\n        if (shouldExtract(text)) {\n          const key = generateKey(text, state._existingKeys!);\n          state._existingKeys!.add(key);\n\n          // Collect extracted content\n          state._extractedContent![key] = text.replace(/\\s+/g, ' ').trim();\n\n          // Track which function has extracted content\n          const funcParent = path.getFunctionParent();\n          if (funcParent?.node.start != null) {\n            state._functionsWithExtractedContent!.add(funcParent.node.start);\n          }\n\n          // Replace with {content.key} or {_compContent.key}\n          path.replaceWith(\n            t.jsxExpressionContainer(\n              t.memberExpression(\n                t.identifier(state._contentVarName!),\n                t.identifier(key),\n                false\n              )\n            )\n          );\n        }\n      },\n\n      /* Extract JSX attributes */\n      JSXAttribute(path, state) {\n        if (!state._isIncluded) return;\n\n        const name = path.node.name;\n\n        if (!t.isJSXIdentifier(name)) return;\n\n        const attrName = name.name;\n        if (!ATTRIBUTES_TO_EXTRACT.includes(attrName)) return;\n\n        const value = path.node.value;\n\n        // Handle both direct StringLiteral and JSXExpressionContainer with StringLiteral\n        // Case 1: attr=\"value\" -> value is StringLiteral\n        // Case 2: attr={\"value\"} -> value is JSXExpressionContainer containing StringLiteral\n        let text: string | null = null;\n\n        if (t.isStringLiteral(value)) {\n          text = value.value;\n        } else if (\n          t.isJSXExpressionContainer(value) &&\n          t.isStringLiteral(value.expression)\n        ) {\n          text = value.expression.value;\n        }\n\n        if (text === null) return;\n\n        const shouldExtract = state.opts.shouldExtract ?? defaultShouldExtract;\n\n        if (shouldExtract(text)) {\n          const key = generateKey(text, state._existingKeys!);\n          state._existingKeys!.add(key);\n\n          // Collect extracted content\n          state._extractedContent![key] = text.trim();\n\n          // Track which function has extracted content\n          const funcParent = path.getFunctionParent();\n          if (funcParent?.node.start != null) {\n            state._functionsWithExtractedContent!.add(funcParent.node.start);\n          }\n\n          // Replace with {content.key.value} or {_compContent.key.value}\n          path.node.value = t.jsxExpressionContainer(\n            t.memberExpression(\n              t.memberExpression(\n                t.identifier(state._contentVarName!),\n                t.identifier(key),\n                false\n              ),\n              t.identifier('value'),\n              false\n            )\n          );\n        }\n      },\n\n      /* Inject useIntlayer hook at program exit */\n      Program: {\n        enter(programPath, state) {\n          if (!state._isIncluded) return;\n\n          // Check if 'content' variable is already used in any function\n          // If so, we'll use '_compContent' to avoid conflicts\n          let contentVarUsed = false;\n\n          programPath.traverse({\n            VariableDeclarator(varPath) {\n              if (\n                t.isIdentifier(varPath.node.id) &&\n                varPath.node.id.name === 'content'\n              ) {\n                contentVarUsed = true;\n              }\n            },\n          });\n\n          state._contentVarName = contentVarUsed ? '_compContent' : 'content';\n        },\n\n        exit(programPath, state) {\n          if (!state._isIncluded) return;\n\n          const extractedKeys = Object.keys(state._extractedContent!);\n          const hasExtractedContent = extractedKeys.length > 0;\n\n          // If no content was extracted, skip - don't inject useIntlayer for files with no extractable text\n          if (!hasExtractedContent) return;\n\n          // Only process JSX files (React components)\n          if (!state._hasJSX) return;\n\n          const defaultLocale = state.opts.defaultLocale;\n          const packageName = state.opts.packageName;\n\n          // Call the onExtract callback with extracted content\n          // This will update the dictionary, adding new keys and removing unused ones\n          if (\n            state.opts.onExtract &&\n            state._dictionaryKey &&\n            hasExtractedContent\n          ) {\n            state.opts.onExtract({\n              dictionaryKey: state._dictionaryKey,\n              filePath: state.file.opts.filename!,\n              content: { ...state._extractedContent! },\n              locale: defaultLocale!,\n            });\n          }\n\n          // Find insertion point (after directives and imports)\n          const bodyPaths = programPath.get(\n            'body'\n          ) as NodePath<BabelTypes.Statement>[];\n\n          // Add useIntlayer import if not already present\n          if (!state._hasUseIntlayerImport) {\n            const importDeclaration = t.importDeclaration(\n              [\n                t.importSpecifier(\n                  t.identifier('useIntlayer'),\n                  t.identifier('useIntlayer')\n                ),\n              ],\n              t.stringLiteral(packageName!)\n            );\n\n            // Find the best position for import (after directives but before other imports)\n            let importInsertPos = 0;\n            for (const stmtPath of bodyPaths) {\n              const stmt = stmtPath.node;\n              if (\n                t.isExpressionStatement(stmt) &&\n                t.isStringLiteral(stmt.expression)\n              ) {\n                importInsertPos += 1;\n                continue;\n              }\n              break;\n            }\n\n            programPath.node.body.splice(importInsertPos, 0, importDeclaration);\n          }\n\n          // Now inject useIntlayer hook only into functions that have extracted content\n          const functionsWithContent = state._functionsWithExtractedContent!;\n\n          programPath.traverse({\n            // Handle function declarations\n            FunctionDeclaration(funcPath) {\n              // Only inject if this function has extracted content\n              if (\n                funcPath.node.start != null &&\n                functionsWithContent.has(funcPath.node.start)\n              ) {\n                injectHookIntoFunction(funcPath, state, t);\n              }\n            },\n\n            // Handle arrow functions and function expressions in variable declarations\n            VariableDeclarator(varPath) {\n              const init = varPath.node.init;\n              if (\n                t.isArrowFunctionExpression(init) ||\n                t.isFunctionExpression(init)\n              ) {\n                // Only inject if this function has extracted content\n                if (\n                  init.start != null &&\n                  functionsWithContent.has(init.start)\n                ) {\n                  injectHookIntoArrowOrExpression(\n                    varPath as NodePath<BabelTypes.VariableDeclarator>,\n                    init,\n                    state,\n                    t\n                  );\n                }\n              }\n            },\n          });\n        },\n      },\n    },\n  };\n};\n\n/**\n * Inject useIntlayer hook into a function declaration\n */\nconst injectHookIntoFunction = (\n  funcPath: NodePath<BabelTypes.FunctionDeclaration>,\n  state: State,\n  t: typeof BabelTypes\n) => {\n  const body = funcPath.node.body;\n  if (!t.isBlockStatement(body)) return;\n\n  // Check if this function returns JSX\n  let returnsJSX = false;\n  funcPath.traverse({\n    ReturnStatement(returnPath) {\n      const arg = returnPath.node.argument;\n      if (t.isJSXElement(arg) || t.isJSXFragment(arg)) {\n        returnsJSX = true;\n      }\n    },\n  });\n\n  if (!returnsJSX) return;\n\n  const contentVarName = state._contentVarName!;\n\n  // Check if hook with this specific variable name is already injected\n  const hasHook = body.body.some(\n    (stmt) =>\n      t.isVariableDeclaration(stmt) &&\n      stmt.declarations.some(\n        (decl) =>\n          t.isIdentifier(decl.id) &&\n          decl.id.name === contentVarName &&\n          t.isCallExpression(decl.init) &&\n          t.isIdentifier(decl.init.callee) &&\n          decl.init.callee.name === state._useIntlayerLocalName\n      )\n  );\n\n  if (hasHook) return;\n\n  // Inject: const content = useIntlayer('dictionary-key');\n  // or: const _compContent = useIntlayer('comp-dictionary-key');\n  const hookCall = t.variableDeclaration('const', [\n    t.variableDeclarator(\n      t.identifier(contentVarName),\n      t.callExpression(t.identifier(state._useIntlayerLocalName!), [\n        t.stringLiteral(state._dictionaryKey!),\n      ])\n    ),\n  ]);\n\n  body.body.unshift(hookCall);\n};\n\n/**\n * Inject useIntlayer hook into an arrow function or function expression\n */\nconst injectHookIntoArrowOrExpression = (\n  varPath: NodePath<BabelTypes.VariableDeclarator>,\n  init: BabelTypes.ArrowFunctionExpression | BabelTypes.FunctionExpression,\n  state: State,\n  t: typeof BabelTypes\n) => {\n  const body = init.body;\n  const contentVarName = state._contentVarName!;\n\n  // If the body is JSX directly (implicit return), wrap it in a block\n  if (t.isJSXElement(body) || t.isJSXFragment(body)) {\n    // Transform: () => <div>...</div>\n    // To: () => { const content = useIntlayer('key'); return <div>...</div>; }\n    // or: () => { const _compContent = useIntlayer('comp-key'); return <div>...</div>; }\n    const hookCall = t.variableDeclaration('const', [\n      t.variableDeclarator(\n        t.identifier(contentVarName),\n        t.callExpression(t.identifier(state._useIntlayerLocalName!), [\n          t.stringLiteral(state._dictionaryKey!),\n        ])\n      ),\n    ]);\n\n    const returnStmt = t.returnStatement(body);\n    init.body = t.blockStatement([hookCall, returnStmt]);\n    return;\n  }\n\n  if (!t.isBlockStatement(body)) return;\n\n  // Check if this function returns JSX\n  let returnsJSX = false;\n  varPath.traverse({\n    ReturnStatement(returnPath) {\n      const arg = returnPath.node.argument;\n      if (t.isJSXElement(arg) || t.isJSXFragment(arg)) {\n        returnsJSX = true;\n      }\n    },\n  });\n\n  if (!returnsJSX) return;\n\n  // Check if hook with this specific variable name is already injected\n  const hasHook = body.body.some(\n    (stmt) =>\n      t.isVariableDeclaration(stmt) &&\n      stmt.declarations.some(\n        (decl) =>\n          t.isIdentifier(decl.id) &&\n          decl.id.name === contentVarName &&\n          t.isCallExpression(decl.init) &&\n          t.isIdentifier(decl.init.callee) &&\n          decl.init.callee.name === state._useIntlayerLocalName\n      )\n  );\n\n  if (hasHook) return;\n\n  // Inject: const content = useIntlayer('dictionary-key');\n  // or: const _compContent = useIntlayer('comp-dictionary-key');\n  const hookCall = t.variableDeclaration('const', [\n    t.variableDeclarator(\n      t.identifier(contentVarName),\n      t.callExpression(t.identifier(state._useIntlayerLocalName!), [\n        t.stringLiteral(state._dictionaryKey!),\n      ])\n    ),\n  ]);\n\n  body.body.unshift(hookCall);\n};\n"],"mappings":"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"}

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

@@ -1,8 +1,9 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
 let node_path = require("node:path");
 let __intlayer_chokidar = require("@intlayer/chokidar");
 let __intlayer_config = require("@intlayer/config");
 
-//#region src/babel-plugin-intlayer.ts
+//#region src/babel-plugin-intlayer-optimize.ts
 const PACKAGE_LIST = [
 	"intlayer",
 	"@intlayer/core",
@@ -140,7 +141,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 +152,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 +164,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 = (0, __intlayer_chokidar.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 = (0, __intlayer_chokidar.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 = (0, __intlayer_chokidar.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 = (0, __intlayer_chokidar.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
-exports.intlayerBabelPlugin = intlayerBabelPlugin;
-//# sourceMappingURL=babel-plugin-intlayer.cjs.map
+exports.intlayerOptimizeBabelPlugin = intlayerOptimizeBabelPlugin;
+//# sourceMappingURL=babel-plugin-intlayer-optimize.cjs.map