gt 2.14.35 → 2.14.37

package/dist/react/parse/createInlineUpdates.js

@@ -1,144 +1,128 @@
-import fs from 'node:fs';
-import { parse } from '@babel/parser';
-import { parseTranslationComponent } from '../jsx/utils/jsxParsing/parseJsx.js';
-import { parseStrings } from '../jsx/utils/parseStringFunction.js';
-import { logger } from '../../console/logger.js';
-import { matchFiles } from '../../fs/matchFiles.js';
-import { DEFAULT_SRC_PATTERNS } from '../../config/generateSettings.js';
-import { resolveAutoderive } from '../../types/parsing.js';
-import { getPathsAndAliases } from '../jsx/utils/getPathsAndAliases.js';
-import { GT_LIBRARIES_UPSTREAM, REACT_LIBRARIES, } from '../../types/libraries.js';
-import { calculateHashes, dedupeUpdates, linkDeriveUpdates, } from '../../extraction/postProcess.js';
-import { ensureTAndVarImported, autoInsertJsxComponents, } from '../jsx/utils/jsxParsing/autoInsertion.js';
-import { INTERNAL_TRANSLATION_COMPONENT } from '../jsx/utils/constants.js';
-import traverseModule from '@babel/traverse';
+import { logger } from "../../console/logger.js";
+import "../jsx/utils/constants.js";
+import { getPathsAndAliases } from "../jsx/utils/getPathsAndAliases.js";
+import { autoInsertJsxComponents, ensureTAndVarImported } from "../jsx/utils/jsxParsing/autoInsertion.js";
+import { GT_LIBRARIES_UPSTREAM, REACT_LIBRARIES } from "../../types/libraries.js";
+import { parseTranslationComponent } from "../jsx/utils/jsxParsing/parseJsx.js";
+import { parseStrings } from "../jsx/utils/parseStringFunction.js";
+import { matchFiles } from "../../fs/matchFiles.js";
+import { DEFAULT_SRC_PATTERNS } from "../../config/generateSettings.js";
+import { resolveAutoderive } from "../../types/parsing.js";
+import { calculateHashes, dedupeUpdates, linkDeriveUpdates } from "../../extraction/postProcess.js";
+import fs from "node:fs";
+import { parse } from "@babel/parser";
+import traverseModule from "@babel/traverse";
+//#region src/react/parse/createInlineUpdates.ts
 const traverse = traverseModule.default || traverseModule;
-export async function createInlineUpdates(pkg, validate, filePatterns, parsingFlags, parsingOptions) {
-    const updates = [];
-    const errors = [];
-    const warnings = new Set();
-    const pkgs = getUpstreamPackages(pkg);
-    const autoderive = resolveAutoderive(parsingFlags.autoderive);
-    // Use the provided app directory or default to the current directory
-    const files = matchFiles(process.cwd(), filePatterns || DEFAULT_SRC_PATTERNS);
-    for (const file of files) {
-        const code = await fs.promises.readFile(file, 'utf8');
-        let ast;
-        try {
-            ast = parse(code, {
-                sourceType: 'module',
-                plugins: ['jsx', 'typescript'],
-            });
-        }
-        catch (error) {
-            logger.error(`Error parsing file ${file}: ${error}`);
-            continue;
-        }
-        // First pass: collect imports and process translation functions
-        const { importAliases, inlineTranslationPaths, translationComponentPaths } = getPathsAndAliases(ast, pkgs);
-        // Process translation functions asynchronously
-        for (const { localName: name, originalName, path, } of inlineTranslationPaths) {
-            parseStrings(name, originalName, path, {
-                parsingOptions,
-                file,
-                ignoreInlineMetadata: false,
-                ignoreDynamicContent: false,
-                ignoreInvalidIcu: false,
-                ignoreInlineListContent: false,
-                includeSourceCodeContext: parsingFlags.includeSourceCodeContext,
-                ignoreTaggedTemplates: false,
-                ignoreGlobalTaggedTemplates: false,
-                // User configurable, otherwise default to AUTO
-                autoderiveMethod: autoderive.strings ? 'AUTO' : 'DISABLED',
-            }, { updates, errors, warnings });
-        }
-        // Parse <T> components — PASS 1: user-written T
-        if (REACT_LIBRARIES.includes(pkg)) {
-            for (const { localName, path } of translationComponentPaths) {
-                parseTranslationComponent({
-                    originalName: localName,
-                    localName,
-                    path,
-                    updates,
-                    config: {
-                        importAliases,
-                        parsingOptions,
-                        pkgs,
-                        file,
-                        includeSourceCodeContext: parsingFlags.includeSourceCodeContext,
-                        autoderive: autoderive.jsx,
-                    },
-                    output: {
-                        errors,
-                        warnings,
-                        unwrappedExpressions: [],
-                    },
-                });
-            }
-            // PASS 2: Auto-inject GtInternalTranslateJsx and GtInternalVar and extract (flag-gated)
-            if (parsingFlags.enableAutoJsxInjection) {
-                // Add translation component names to importAliases so autoInsertJsxComponents
-                // recognizes user T as hands-off (getPathsAndAliases separates them out)
-                for (const { localName, originalName } of translationComponentPaths) {
-                    importAliases[localName] = originalName;
-                }
-                // Ensure GtInternalTranslateJsx and GtInternalVar are imported in the AST
-                ensureTAndVarImported(ast, importAliases);
-                // Insert T/Var into the AST
-                autoInsertJsxComponents(ast, importAliases);
-                // Refresh scope to pick up new T references
-                traverse(ast, {
-                    Program(programPath) {
-                        programPath.scope.crawl();
-                    },
-                });
-                // Re-collect with updated AST
-                const refreshed = getPathsAndAliases(ast, pkgs);
-                // Add translation component names to refreshed aliases so parseJsx
-                // can recognize GtInternalTranslateJsx inside Derive for transparent unwrap
-                for (const { localName: tLocalName, originalName: tOrigName, } of refreshed.translationComponentPaths) {
-                    refreshed.importAliases[tLocalName] = tOrigName;
-                }
-                // Extract only from auto-injected GtInternalTranslateJsx — never re-extract user T
-                for (const { localName, path, originalName, } of refreshed.translationComponentPaths) {
-                    if (originalName !== INTERNAL_TRANSLATION_COMPONENT)
-                        continue;
-                    parseTranslationComponent({
-                        originalName: localName,
-                        localName,
-                        path,
-                        updates,
-                        config: {
-                            importAliases: refreshed.importAliases,
-                            parsingOptions,
-                            pkgs,
-                            file,
-                            includeSourceCodeContext: parsingFlags.includeSourceCodeContext,
-                            enableAutoJsxInjection: true,
-                            autoderive: autoderive.jsx,
-                        },
-                        output: {
-                            errors,
-                            warnings,
-                            unwrappedExpressions: [],
-                        },
-                    });
-                }
-            }
-        }
-    }
-    // Post processing steps:
-    await calculateHashes(updates);
-    dedupeUpdates(updates);
-    linkDeriveUpdates(updates);
-    return { updates, errors, warnings: [...warnings] };
+async function createInlineUpdates(pkg, validate, filePatterns, parsingFlags, parsingOptions) {
+	const updates = [];
+	const errors = [];
+	const warnings = /* @__PURE__ */ new Set();
+	const pkgs = getUpstreamPackages(pkg);
+	const autoderive = resolveAutoderive(parsingFlags.autoderive);
+	const files = matchFiles(process.cwd(), filePatterns || DEFAULT_SRC_PATTERNS);
+	for (const file of files) {
+		const code = await fs.promises.readFile(file, "utf8");
+		let ast;
+		try {
+			ast = parse(code, {
+				sourceType: "module",
+				plugins: ["jsx", "typescript"]
+			});
+		} catch (error) {
+			logger.error(`Error parsing file ${file}: ${error}`);
+			continue;
+		}
+		const { importAliases, inlineTranslationPaths, translationComponentPaths } = getPathsAndAliases(ast, pkgs);
+		for (const { localName: name, originalName, path } of inlineTranslationPaths) parseStrings(name, originalName, path, {
+			parsingOptions,
+			file,
+			ignoreInlineMetadata: false,
+			ignoreDynamicContent: false,
+			ignoreInvalidIcu: false,
+			ignoreInlineListContent: false,
+			includeSourceCodeContext: parsingFlags.includeSourceCodeContext,
+			ignoreTaggedTemplates: false,
+			ignoreGlobalTaggedTemplates: false,
+			autoderiveMethod: autoderive.strings ? "AUTO" : "DISABLED"
+		}, {
+			updates,
+			errors,
+			warnings
+		});
+		if (REACT_LIBRARIES.includes(pkg)) {
+			for (const { localName, path } of translationComponentPaths) parseTranslationComponent({
+				originalName: localName,
+				localName,
+				path,
+				updates,
+				config: {
+					importAliases,
+					parsingOptions,
+					pkgs,
+					file,
+					includeSourceCodeContext: parsingFlags.includeSourceCodeContext,
+					autoderive: autoderive.jsx
+				},
+				output: {
+					errors,
+					warnings,
+					unwrappedExpressions: []
+				}
+			});
+			if (parsingFlags.enableAutoJsxInjection) {
+				for (const { localName, originalName } of translationComponentPaths) importAliases[localName] = originalName;
+				ensureTAndVarImported(ast, importAliases);
+				autoInsertJsxComponents(ast, importAliases);
+				traverse(ast, { Program(programPath) {
+					programPath.scope.crawl();
+				} });
+				const refreshed = getPathsAndAliases(ast, pkgs);
+				for (const { localName: tLocalName, originalName: tOrigName } of refreshed.translationComponentPaths) refreshed.importAliases[tLocalName] = tOrigName;
+				for (const { localName, path, originalName } of refreshed.translationComponentPaths) {
+					if (originalName !== "GtInternalTranslateJsx") continue;
+					parseTranslationComponent({
+						originalName: localName,
+						localName,
+						path,
+						updates,
+						config: {
+							importAliases: refreshed.importAliases,
+							parsingOptions,
+							pkgs,
+							file,
+							includeSourceCodeContext: parsingFlags.includeSourceCodeContext,
+							enableAutoJsxInjection: true,
+							autoderive: autoderive.jsx
+						},
+						output: {
+							errors,
+							warnings,
+							unwrappedExpressions: []
+						}
+					});
+				}
+			}
+		}
+	}
+	await calculateHashes(updates);
+	dedupeUpdates(updates);
+	linkDeriveUpdates(updates);
+	return {
+		updates,
+		errors,
+		warnings: [...warnings]
+	};
 }
 /**
- * Given a package name, return the upstream packages that it depends on
- * @param pkg - The package name
- * @returns The upstream packages that the package depends on
- */
+* Given a package name, return the upstream packages that it depends on
+* @param pkg - The package name
+* @returns The upstream packages that the package depends on
+*/
 function getUpstreamPackages(pkg) {
-    return GT_LIBRARIES_UPSTREAM[pkg];
+	return GT_LIBRARIES_UPSTREAM[pkg];
 }
-export { dedupeUpdates as _test_dedupeUpdates };
+//#endregion
+export { dedupeUpdates as _test_dedupeUpdates, createInlineUpdates };
+
+//# sourceMappingURL=createInlineUpdates.js.map

package/dist/react/parse/createInlineUpdates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createInlineUpdates.js","names":[],"sources":["../../../src/react/parse/createInlineUpdates.ts"],"sourcesContent":["import fs from 'node:fs';\nimport { Updates } from '../../types/index.js';\n\nimport { parse } from '@babel/parser';\nimport { parseTranslationComponent } from '../jsx/utils/jsxParsing/parseJsx.js';\nimport { parseStrings } from '../jsx/utils/parseStringFunction.js';\nimport { logger } from '../../console/logger.js';\nimport { matchFiles } from '../../fs/matchFiles.js';\nimport { DEFAULT_SRC_PATTERNS } from '../../config/generateSettings.js';\nimport type {\n  ParsingConfigOptions,\n  GTParsingFlags,\n} from '../../types/parsing.js';\nimport { resolveAutoderive } from '../../types/parsing.js';\nimport { getPathsAndAliases } from '../jsx/utils/getPathsAndAliases.js';\nimport {\n  GTLibrary,\n  GT_LIBRARIES_UPSTREAM,\n  REACT_LIBRARIES,\n  ReactLibrary,\n} from '../../types/libraries.js';\nimport {\n  calculateHashes,\n  dedupeUpdates,\n  linkDeriveUpdates,\n} from '../../extraction/postProcess.js';\nimport {\n  ensureTAndVarImported,\n  autoInsertJsxComponents,\n} from '../jsx/utils/jsxParsing/autoInsertion.js';\nimport { INTERNAL_TRANSLATION_COMPONENT } from '../jsx/utils/constants.js';\nimport traverseModule from '@babel/traverse';\nconst traverse = traverseModule.default || traverseModule;\n\nexport async function createInlineUpdates(\n  pkg: GTLibrary,\n  validate: boolean,\n  filePatterns: string[] | undefined,\n  parsingFlags: GTParsingFlags,\n  parsingOptions: ParsingConfigOptions\n): Promise<{ updates: Updates; errors: string[]; warnings: string[] }> {\n  const updates: Updates = [];\n\n  const errors: string[] = [];\n  const warnings: Set<string> = new Set();\n\n  const pkgs = getUpstreamPackages(pkg);\n\n  const autoderive = resolveAutoderive(parsingFlags.autoderive);\n\n  // Use the provided app directory or default to the current directory\n  const files = matchFiles(process.cwd(), filePatterns || DEFAULT_SRC_PATTERNS);\n\n  for (const file of files) {\n    const code = await fs.promises.readFile(file, 'utf8');\n    let ast;\n    try {\n      ast = parse(code, {\n        sourceType: 'module',\n        plugins: ['jsx', 'typescript'],\n      });\n    } catch (error) {\n      logger.error(`Error parsing file ${file}: ${error}`);\n      continue;\n    }\n\n    // First pass: collect imports and process translation functions\n    const { importAliases, inlineTranslationPaths, translationComponentPaths } =\n      getPathsAndAliases(ast, pkgs);\n\n    // Process translation functions asynchronously\n    for (const {\n      localName: name,\n      originalName,\n      path,\n    } of inlineTranslationPaths) {\n      parseStrings(\n        name,\n        originalName,\n        path,\n        {\n          parsingOptions,\n          file,\n          ignoreInlineMetadata: false,\n          ignoreDynamicContent: false,\n          ignoreInvalidIcu: false,\n          ignoreInlineListContent: false,\n          includeSourceCodeContext: parsingFlags.includeSourceCodeContext,\n          ignoreTaggedTemplates: false,\n          ignoreGlobalTaggedTemplates: false,\n          // User configurable, otherwise default to AUTO\n          autoderiveMethod: autoderive.strings ? 'AUTO' : 'DISABLED',\n        },\n        { updates, errors, warnings }\n      );\n    }\n\n    // Parse <T> components — PASS 1: user-written T\n    if (REACT_LIBRARIES.includes(pkg as ReactLibrary)) {\n      for (const { localName, path } of translationComponentPaths) {\n        parseTranslationComponent({\n          originalName: localName,\n          localName,\n          path,\n          updates,\n          config: {\n            importAliases,\n            parsingOptions,\n            pkgs,\n            file,\n            includeSourceCodeContext: parsingFlags.includeSourceCodeContext,\n            autoderive: autoderive.jsx,\n          },\n          output: {\n            errors,\n            warnings,\n            unwrappedExpressions: [],\n          },\n        });\n      }\n\n      // PASS 2: Auto-inject GtInternalTranslateJsx and GtInternalVar and extract (flag-gated)\n      if (parsingFlags.enableAutoJsxInjection) {\n        // Add translation component names to importAliases so autoInsertJsxComponents\n        // recognizes user T as hands-off (getPathsAndAliases separates them out)\n        for (const { localName, originalName } of translationComponentPaths) {\n          importAliases[localName] = originalName;\n        }\n\n        // Ensure GtInternalTranslateJsx and GtInternalVar are imported in the AST\n        ensureTAndVarImported(ast, importAliases);\n\n        // Insert T/Var into the AST\n        autoInsertJsxComponents(ast, importAliases);\n\n        // Refresh scope to pick up new T references\n        traverse(ast, {\n          Program(programPath) {\n            programPath.scope.crawl();\n          },\n        });\n\n        // Re-collect with updated AST\n        const refreshed = getPathsAndAliases(ast, pkgs);\n\n        // Add translation component names to refreshed aliases so parseJsx\n        // can recognize GtInternalTranslateJsx inside Derive for transparent unwrap\n        for (const {\n          localName: tLocalName,\n          originalName: tOrigName,\n        } of refreshed.translationComponentPaths) {\n          refreshed.importAliases[tLocalName] = tOrigName;\n        }\n\n        // Extract only from auto-injected GtInternalTranslateJsx — never re-extract user T\n        for (const {\n          localName,\n          path,\n          originalName,\n        } of refreshed.translationComponentPaths) {\n          if (originalName !== INTERNAL_TRANSLATION_COMPONENT) continue;\n          parseTranslationComponent({\n            originalName: localName,\n            localName,\n            path,\n            updates,\n            config: {\n              importAliases: refreshed.importAliases,\n              parsingOptions,\n              pkgs,\n              file,\n              includeSourceCodeContext: parsingFlags.includeSourceCodeContext,\n              enableAutoJsxInjection: true,\n              autoderive: autoderive.jsx,\n            },\n            output: {\n              errors,\n              warnings,\n              unwrappedExpressions: [],\n            },\n          });\n        }\n      }\n    }\n  }\n\n  // Post processing steps:\n  await calculateHashes(updates);\n  dedupeUpdates(updates);\n  linkDeriveUpdates(updates);\n\n  return { updates, errors, warnings: [...warnings] };\n}\n\n/**\n * Given a package name, return the upstream packages that it depends on\n * @param pkg - The package name\n * @returns The upstream packages that the package depends on\n */\nfunction getUpstreamPackages(pkg: GTLibrary): GTLibrary[] {\n  return GT_LIBRARIES_UPSTREAM[pkg];\n}\n\nexport { dedupeUpdates as _test_dedupeUpdates };\n"],"mappings":";;;;;;;;;;;;;;;AAgCA,MAAM,WAAW,eAAe,WAAW;AAE3C,eAAsB,oBACpB,KACA,UACA,cACA,cACA,gBACqE;CACrE,MAAM,UAAmB,EAAE;CAE3B,MAAM,SAAmB,EAAE;CAC3B,MAAM,2BAAwB,IAAI,KAAK;CAEvC,MAAM,OAAO,oBAAoB,IAAI;CAErC,MAAM,aAAa,kBAAkB,aAAa,WAAW;CAG7D,MAAM,QAAQ,WAAW,QAAQ,KAAK,EAAE,gBAAgB,qBAAqB;AAE7E,MAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,OAAO,MAAM,GAAG,SAAS,SAAS,MAAM,OAAO;EACrD,IAAI;AACJ,MAAI;AACF,SAAM,MAAM,MAAM;IAChB,YAAY;IACZ,SAAS,CAAC,OAAO,aAAa;IAC/B,CAAC;WACK,OAAO;AACd,UAAO,MAAM,sBAAsB,KAAK,IAAI,QAAQ;AACpD;;EAIF,MAAM,EAAE,eAAe,wBAAwB,8BAC7C,mBAAmB,KAAK,KAAK;AAG/B,OAAK,MAAM,EACT,WAAW,MACX,cACA,UACG,uBACH,cACE,MACA,cACA,MACA;GACE;GACA;GACA,sBAAsB;GACtB,sBAAsB;GACtB,kBAAkB;GAClB,yBAAyB;GACzB,0BAA0B,aAAa;GACvC,uBAAuB;GACvB,6BAA6B;GAE7B,kBAAkB,WAAW,UAAU,SAAS;GACjD,EACD;GAAE;GAAS;GAAQ;GAAU,CAC9B;AAIH,MAAI,gBAAgB,SAAS,IAAoB,EAAE;AACjD,QAAK,MAAM,EAAE,WAAW,UAAU,0BAChC,2BAA0B;IACxB,cAAc;IACd;IACA;IACA;IACA,QAAQ;KACN;KACA;KACA;KACA;KACA,0BAA0B,aAAa;KACvC,YAAY,WAAW;KACxB;IACD,QAAQ;KACN;KACA;KACA,sBAAsB,EAAE;KACzB;IACF,CAAC;AAIJ,OAAI,aAAa,wBAAwB;AAGvC,SAAK,MAAM,EAAE,WAAW,kBAAkB,0BACxC,eAAc,aAAa;AAI7B,0BAAsB,KAAK,cAAc;AAGzC,4BAAwB,KAAK,cAAc;AAG3C,aAAS,KAAK,EACZ,QAAQ,aAAa;AACnB,iBAAY,MAAM,OAAO;OAE5B,CAAC;IAGF,MAAM,YAAY,mBAAmB,KAAK,KAAK;AAI/C,SAAK,MAAM,EACT,WAAW,YACX,cAAc,eACX,UAAU,0BACb,WAAU,cAAc,cAAc;AAIxC,SAAK,MAAM,EACT,WACA,MACA,kBACG,UAAU,2BAA2B;AACxC,SAAI,iBAAA,yBAAiD;AACrD,+BAA0B;MACxB,cAAc;MACd;MACA;MACA;MACA,QAAQ;OACN,eAAe,UAAU;OACzB;OACA;OACA;OACA,0BAA0B,aAAa;OACvC,wBAAwB;OACxB,YAAY,WAAW;OACxB;MACD,QAAQ;OACN;OACA;OACA,sBAAsB,EAAE;OACzB;MACF,CAAC;;;;;AAOV,OAAM,gBAAgB,QAAQ;AAC9B,eAAc,QAAQ;AACtB,mBAAkB,QAAQ;AAE1B,QAAO;EAAE;EAAS;EAAQ,UAAU,CAAC,GAAG,SAAS;EAAE;;;;;;;AAQrD,SAAS,oBAAoB,KAA6B;AACxD,QAAO,sBAAsB"}

package/dist/react/parse/wrapContent.js

@@ -1,162 +1,137 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import * as t from '@babel/types';
-import { parse } from '@babel/parser';
-import traverseModule from '@babel/traverse';
-import generateModule from '@babel/generator';
-// Handle CommonJS/ESM interop
+import { getRelativePath } from "../../fs/findFilepath.js";
+import { isMeaningful } from "../jsx/evaluateJsx.js";
+import { createImports, generateImportMap } from "../jsx/utils/parseAst.js";
+import "../../types/libraries.js";
+import { matchFiles } from "../../fs/matchFiles.js";
+import { DEFAULT_SRC_PATTERNS } from "../../config/generateSettings.js";
+import { handleJsxElement } from "../jsx/wrapJsx.js";
+import path from "node:path";
+import fs from "node:fs";
+import * as t from "@babel/types";
+import { parse } from "@babel/parser";
+import generateModule from "@babel/generator";
+import traverseModule from "@babel/traverse";
+//#region src/react/parse/wrapContent.ts
 const traverse = traverseModule.default || traverseModule;
 const generate = generateModule.default || generateModule;
-import { isMeaningful } from '../jsx/evaluateJsx.js';
-import { handleJsxElement } from '../jsx/wrapJsx.js';
-import { getRelativePath } from '../../fs/findFilepath.js';
-import { generateImportMap, createImports, } from '../jsx/utils/parseAst.js';
-import { DEFAULT_SRC_PATTERNS } from '../../config/generateSettings.js';
-import { matchFiles } from '../../fs/matchFiles.js';
-import { Libraries } from '../../types/libraries.js';
 const IMPORT_MAP = {
-    T: { name: 'T', source: Libraries.GT_REACT },
-    Var: { name: 'Var', source: Libraries.GT_REACT },
-    GTT: { name: 'T', source: Libraries.GT_REACT },
-    GTVar: { name: 'Var', source: Libraries.GT_REACT },
-    GTProvider: { name: 'GTProvider', source: Libraries.GT_REACT },
+	T: {
+		name: "T",
+		source: "gt-react"
+	},
+	Var: {
+		name: "Var",
+		source: "gt-react"
+	},
+	GTT: {
+		name: "T",
+		source: "gt-react"
+	},
+	GTVar: {
+		name: "Var",
+		source: "gt-react"
+	},
+	GTProvider: {
+		name: "GTProvider",
+		source: "gt-react"
+	}
 };
 /**
- * Wraps all JSX elements in the src directory with a <T> tag, with unique ids.
- * - Ignores pure strings
- *
- * @param options - The options object
- * @returns An object containing the updates and errors
- */
-export async function wrapContentReact(options, pkg, framework, errors, warnings) {
-    const filePatterns = options.src || DEFAULT_SRC_PATTERNS;
-    const files = matchFiles(process.cwd(), filePatterns);
-    const filesUpdated = [];
-    for (const file of files) {
-        const baseFileName = path.basename(file);
-        const configPath = path.relative(path.dirname(file), path.resolve(process.cwd(), options.config));
-        // Ensure the path starts with ./ or ../
-        const normalizedConfigPath = configPath.startsWith('.')
-            ? configPath
-            : './' + configPath;
-        const code = await fs.promises.readFile(file, 'utf8');
-        // Create relative path from src directory and remove extension
-        const relativePath = getRelativePath(file, process.cwd());
-        let ast;
-        try {
-            ast = parse(code, {
-                sourceType: 'module',
-                plugins: ['jsx', 'typescript'],
-                tokens: true,
-                createParenthesizedExpressions: true,
-            });
-        }
-        catch (error) {
-            errors.push(`Error:Failed to parse ${file}: ${error}`);
-            continue;
-        }
-        let modified = false;
-        const usedImports = [];
-        const { importAlias, initialImports } = generateImportMap(ast, pkg);
-        // If the file already has a T import, skip processing it
-        if (initialImports.includes(IMPORT_MAP.T.name)) {
-            continue;
-        }
-        let globalId = 0;
-        traverse(ast, {
-            JSXElement(path) {
-                if (framework === 'next-pages' &&
-                    options.addGTProvider &&
-                    (baseFileName === '_app.tsx' || baseFileName === '_app.jsx')) {
-                    // Check if this is the Component element with pageProps
-                    const isComponentWithPageProps = t.isJSXElement(path.node) &&
-                        t.isJSXIdentifier(path.node.openingElement.name) &&
-                        path.node.openingElement.name.name === 'Component' &&
-                        path.node.openingElement.attributes.some((attr) => t.isJSXSpreadAttribute(attr) &&
-                            t.isIdentifier(attr.argument) &&
-                            attr.argument.name === 'pageProps');
-                    if (!isComponentWithPageProps) {
-                        return;
-                    }
-                    // Check if GTProvider already exists in the ancestors
-                    let hasGTProvider = false;
-                    let currentPath = path;
-                    while (currentPath.parentPath) {
-                        if (t.isJSXElement(currentPath.node) &&
-                            t.isJSXIdentifier(currentPath.node.openingElement.name) &&
-                            currentPath.node.openingElement.name.name === 'GTProvider') {
-                            hasGTProvider = true;
-                            break;
-                        }
-                        currentPath = currentPath.parentPath;
-                    }
-                    if (!hasGTProvider) {
-                        // Wrap the Component element with GTProvider
-                        const gtProviderJsx = t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier('GTProvider'), [t.jsxSpreadAttribute(t.identifier('gtConfig'))], false), t.jsxClosingElement(t.jsxIdentifier('GTProvider')), [path.node]);
-                        path.replaceWith(gtProviderJsx);
-                        usedImports.push('GTProvider');
-                        usedImports.push({
-                            local: 'gtConfig',
-                            imported: 'default',
-                            source: normalizedConfigPath,
-                        });
-                        modified = true;
-                        path.skip();
-                        return;
-                    }
-                }
-                // Check if this JSX element has any JSX element ancestors
-                if (t.isJSXElement(path.parentPath?.node) ||
-                    t.isJSXExpressionContainer(path.parentPath?.node)) {
-                    // If we're nested inside JSX, skip processing this node
-                    return;
-                }
-                // At this point, we're only processing top-level JSX elements
-                const opts = {
-                    ...importAlias,
-                    idPrefix: relativePath,
-                    idCount: globalId,
-                    usedImports,
-                    modified: false,
-                    createIds: !options.disableIds,
-                    warnings,
-                    file,
-                };
-                const wrapped = handleJsxElement(path.node, opts, isMeaningful);
-                path.replaceWith(wrapped.node);
-                // Update global counters
-                modified = modified || opts.modified;
-                globalId = opts.idCount;
-            },
-        });
-        if (!modified)
-            continue;
-        const needsImport = usedImports.filter((imp) => typeof imp === 'string'
-            ? !initialImports.includes(imp)
-            : !initialImports.includes(imp.local));
-        if (needsImport.length > 0) {
-            createImports(ast, needsImport, IMPORT_MAP);
-        }
-        try {
-            const output = generate(ast, {
-                retainLines: true,
-                retainFunctionParens: true,
-                comments: true,
-                compact: 'auto',
-            }, code);
-            // Post-process the output to fix import spacing
-            let processedCode = output.code;
-            if (needsImport.length > 0) {
-                // Add newline after the comment only
-                processedCode = processedCode.replace(/((?:import\s*{\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale)(?:\s*,\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale))*\s*}\s*from|const\s*{\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale)(?:\s*,\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale))*\s*}\s*=\s*require)\s*['"]gt-(?:next|react)(?:\/server)?['"];?)/, '\n$1\n');
-            }
-            // Write the modified code back to the file
-            await fs.promises.writeFile(file, processedCode);
-            filesUpdated.push(file);
-        }
-        catch (error) {
-            errors.push(`Error: Failed to write ${file}: ${error}`);
-        }
-    }
-    return { filesUpdated };
+* Wraps all JSX elements in the src directory with a <T> tag, with unique ids.
+* - Ignores pure strings
+*
+* @param options - The options object
+* @returns An object containing the updates and errors
+*/
+async function wrapContentReact(options, pkg, framework, errors, warnings) {
+	const filePatterns = options.src || DEFAULT_SRC_PATTERNS;
+	const files = matchFiles(process.cwd(), filePatterns);
+	const filesUpdated = [];
+	for (const file of files) {
+		const baseFileName = path.basename(file);
+		const configPath = path.relative(path.dirname(file), path.resolve(process.cwd(), options.config));
+		const normalizedConfigPath = configPath.startsWith(".") ? configPath : "./" + configPath;
+		const code = await fs.promises.readFile(file, "utf8");
+		const relativePath = getRelativePath(file, process.cwd());
+		let ast;
+		try {
+			ast = parse(code, {
+				sourceType: "module",
+				plugins: ["jsx", "typescript"],
+				tokens: true,
+				createParenthesizedExpressions: true
+			});
+		} catch (error) {
+			errors.push(`Error:Failed to parse ${file}: ${error}`);
+			continue;
+		}
+		let modified = false;
+		const usedImports = [];
+		const { importAlias, initialImports } = generateImportMap(ast, pkg);
+		if (initialImports.includes(IMPORT_MAP.T.name)) continue;
+		let globalId = 0;
+		traverse(ast, { JSXElement(path) {
+			if (framework === "next-pages" && options.addGTProvider && (baseFileName === "_app.tsx" || baseFileName === "_app.jsx")) {
+				if (!(t.isJSXElement(path.node) && t.isJSXIdentifier(path.node.openingElement.name) && path.node.openingElement.name.name === "Component" && path.node.openingElement.attributes.some((attr) => t.isJSXSpreadAttribute(attr) && t.isIdentifier(attr.argument) && attr.argument.name === "pageProps"))) return;
+				let hasGTProvider = false;
+				let currentPath = path;
+				while (currentPath.parentPath) {
+					if (t.isJSXElement(currentPath.node) && t.isJSXIdentifier(currentPath.node.openingElement.name) && currentPath.node.openingElement.name.name === "GTProvider") {
+						hasGTProvider = true;
+						break;
+					}
+					currentPath = currentPath.parentPath;
+				}
+				if (!hasGTProvider) {
+					const gtProviderJsx = t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier("GTProvider"), [t.jsxSpreadAttribute(t.identifier("gtConfig"))], false), t.jsxClosingElement(t.jsxIdentifier("GTProvider")), [path.node]);
+					path.replaceWith(gtProviderJsx);
+					usedImports.push("GTProvider");
+					usedImports.push({
+						local: "gtConfig",
+						imported: "default",
+						source: normalizedConfigPath
+					});
+					modified = true;
+					path.skip();
+					return;
+				}
+			}
+			if (t.isJSXElement(path.parentPath?.node) || t.isJSXExpressionContainer(path.parentPath?.node)) return;
+			const opts = {
+				...importAlias,
+				idPrefix: relativePath,
+				idCount: globalId,
+				usedImports,
+				modified: false,
+				createIds: !options.disableIds,
+				warnings,
+				file
+			};
+			const wrapped = handleJsxElement(path.node, opts, isMeaningful);
+			path.replaceWith(wrapped.node);
+			modified = modified || opts.modified;
+			globalId = opts.idCount;
+		} });
+		if (!modified) continue;
+		const needsImport = usedImports.filter((imp) => typeof imp === "string" ? !initialImports.includes(imp) : !initialImports.includes(imp.local));
+		if (needsImport.length > 0) createImports(ast, needsImport, IMPORT_MAP);
+		try {
+			let processedCode = generate(ast, {
+				retainLines: true,
+				retainFunctionParens: true,
+				comments: true,
+				compact: "auto"
+			}, code).code;
+			if (needsImport.length > 0) processedCode = processedCode.replace(/((?:import\s*{\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale)(?:\s*,\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale))*\s*}\s*from|const\s*{\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale)(?:\s*,\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale))*\s*}\s*=\s*require)\s*['"]gt-(?:next|react)(?:\/server)?['"];?)/, "\n$1\n");
+			await fs.promises.writeFile(file, processedCode);
+			filesUpdated.push(file);
+		} catch (error) {
+			errors.push(`Error: Failed to write ${file}: ${error}`);
+		}
+	}
+	return { filesUpdated };
 }
+//#endregion
+export { wrapContentReact };
+
+//# sourceMappingURL=wrapContent.js.map

package/dist/react/parse/wrapContent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapContent.js","names":[],"sources":["../../../src/react/parse/wrapContent.ts"],"sourcesContent":["import fs from 'node:fs';\nimport path from 'node:path';\nimport { SupportedFrameworks, WrapOptions } from '../../types/index.js';\nimport * as t from '@babel/types';\nimport { parse } from '@babel/parser';\nimport traverseModule from '@babel/traverse';\nimport generateModule from '@babel/generator';\nimport { NodePath } from '@babel/traverse';\n\n// Handle CommonJS/ESM interop\nconst traverse = traverseModule.default || traverseModule;\nconst generate = generateModule.default || generateModule;\nimport { isMeaningful } from '../jsx/evaluateJsx.js';\nimport { handleJsxElement } from '../jsx/wrapJsx.js';\nimport { getRelativePath } from '../../fs/findFilepath.js';\nimport {\n  generateImportMap,\n  createImports,\n  ImportItem,\n} from '../jsx/utils/parseAst.js';\nimport { DEFAULT_SRC_PATTERNS } from '../../config/generateSettings.js';\nimport { matchFiles } from '../../fs/matchFiles.js';\nimport { Libraries } from '../../types/libraries.js';\n\nconst IMPORT_MAP = {\n  T: { name: 'T', source: Libraries.GT_REACT },\n  Var: { name: 'Var', source: Libraries.GT_REACT },\n  GTT: { name: 'T', source: Libraries.GT_REACT },\n  GTVar: { name: 'Var', source: Libraries.GT_REACT },\n  GTProvider: { name: 'GTProvider', source: Libraries.GT_REACT },\n};\n\n/**\n * Wraps all JSX elements in the src directory with a <T> tag, with unique ids.\n * - Ignores pure strings\n *\n * @param options - The options object\n * @returns An object containing the updates and errors\n */\nexport async function wrapContentReact(\n  options: WrapOptions,\n  pkg: `${typeof Libraries.GT_REACT}`,\n  framework: SupportedFrameworks,\n  errors: string[],\n  warnings: string[]\n): Promise<{ filesUpdated: string[] }> {\n  const filePatterns = options.src || DEFAULT_SRC_PATTERNS;\n\n  const files = matchFiles(process.cwd(), filePatterns);\n  const filesUpdated = [];\n\n  for (const file of files) {\n    const baseFileName = path.basename(file);\n    const configPath = path.relative(\n      path.dirname(file),\n      path.resolve(process.cwd(), options.config)\n    );\n\n    // Ensure the path starts with ./ or ../\n    const normalizedConfigPath = configPath.startsWith('.')\n      ? configPath\n      : './' + configPath;\n\n    const code = await fs.promises.readFile(file, 'utf8');\n\n    // Create relative path from src directory and remove extension\n    const relativePath = getRelativePath(file, process.cwd());\n\n    let ast;\n    try {\n      ast = parse(code, {\n        sourceType: 'module',\n        plugins: ['jsx', 'typescript'],\n        tokens: true,\n        createParenthesizedExpressions: true,\n      });\n    } catch (error) {\n      errors.push(`Error:Failed to parse ${file}: ${error}`);\n      continue;\n    }\n\n    let modified = false;\n    const usedImports: ImportItem[] = [];\n\n    const { importAlias, initialImports } = generateImportMap(ast, pkg);\n\n    // If the file already has a T import, skip processing it\n    if (initialImports.includes(IMPORT_MAP.T.name)) {\n      continue;\n    }\n\n    let globalId = 0;\n    traverse(ast, {\n      JSXElement(path) {\n        if (\n          framework === 'next-pages' &&\n          options.addGTProvider &&\n          (baseFileName === '_app.tsx' || baseFileName === '_app.jsx')\n        ) {\n          // Check if this is the Component element with pageProps\n          const isComponentWithPageProps =\n            t.isJSXElement(path.node) &&\n            t.isJSXIdentifier(path.node.openingElement.name) &&\n            path.node.openingElement.name.name === 'Component' &&\n            path.node.openingElement.attributes.some(\n              (attr) =>\n                t.isJSXSpreadAttribute(attr) &&\n                t.isIdentifier(attr.argument) &&\n                attr.argument.name === 'pageProps'\n            );\n\n          if (!isComponentWithPageProps) {\n            return;\n          }\n\n          // Check if GTProvider already exists in the ancestors\n          let hasGTProvider = false;\n          let currentPath: NodePath = path;\n\n          while (currentPath.parentPath) {\n            if (\n              t.isJSXElement(currentPath.node) &&\n              t.isJSXIdentifier(currentPath.node.openingElement.name) &&\n              currentPath.node.openingElement.name.name === 'GTProvider'\n            ) {\n              hasGTProvider = true;\n              break;\n            }\n            currentPath = currentPath.parentPath;\n          }\n\n          if (!hasGTProvider) {\n            // Wrap the Component element with GTProvider\n            const gtProviderJsx = t.jsxElement(\n              t.jsxOpeningElement(\n                t.jsxIdentifier('GTProvider'),\n                [t.jsxSpreadAttribute(t.identifier('gtConfig'))],\n                false\n              ),\n              t.jsxClosingElement(t.jsxIdentifier('GTProvider')),\n              [path.node]\n            );\n\n            path.replaceWith(gtProviderJsx);\n            usedImports.push('GTProvider');\n            usedImports.push({\n              local: 'gtConfig',\n              imported: 'default',\n              source: normalizedConfigPath,\n            });\n            modified = true;\n            path.skip();\n            return;\n          }\n        }\n\n        // Check if this JSX element has any JSX element ancestors\n        if (\n          t.isJSXElement(path.parentPath?.node) ||\n          t.isJSXExpressionContainer(path.parentPath?.node)\n        ) {\n          // If we're nested inside JSX, skip processing this node\n          return;\n        }\n\n        // At this point, we're only processing top-level JSX elements\n        const opts = {\n          ...importAlias,\n          idPrefix: relativePath,\n          idCount: globalId,\n          usedImports,\n          modified: false,\n          createIds: !options.disableIds,\n          warnings,\n          file,\n        };\n        const wrapped = handleJsxElement(path.node, opts, isMeaningful);\n        path.replaceWith(wrapped.node);\n\n        // Update global counters\n        modified = modified || opts.modified;\n        globalId = opts.idCount;\n      },\n    });\n    if (!modified) continue;\n\n    const needsImport = usedImports.filter((imp) =>\n      typeof imp === 'string'\n        ? !initialImports.includes(imp)\n        : !initialImports.includes(imp.local)\n    );\n\n    if (needsImport.length > 0) {\n      createImports(ast, needsImport, IMPORT_MAP);\n    }\n\n    try {\n      const output = generate(\n        ast,\n        {\n          retainLines: true,\n          retainFunctionParens: true,\n          comments: true,\n          compact: 'auto',\n        },\n        code\n      );\n\n      // Post-process the output to fix import spacing\n      let processedCode = output.code;\n      if (needsImport.length > 0) {\n        // Add newline after the comment only\n        processedCode = processedCode.replace(\n          /((?:import\\s*{\\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale)(?:\\s*,\\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale))*\\s*}\\s*from|const\\s*{\\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale)(?:\\s*,\\s*(?:T|GTT|Var|GTVar|GTProvider|getLocale))*\\s*}\\s*=\\s*require)\\s*['\"]gt-(?:next|react)(?:\\/server)?['\"];?)/,\n          '\\n$1\\n'\n        );\n      }\n\n      // Write the modified code back to the file\n      await fs.promises.writeFile(file, processedCode);\n      filesUpdated.push(file);\n    } catch (error) {\n      errors.push(`Error: Failed to write ${file}: ${error}`);\n    }\n  }\n\n  return { filesUpdated };\n}\n"],"mappings":"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"}