gtx-cli 2.1.6 → 2.1.8-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # gtx-cli
 
+## 2.1.8
+
+### Patch Changes
+
+- [#594](https://github.com/generaltranslation/gt/pull/594) [`3fa9c41`](https://github.com/generaltranslation/gt/commit/3fa9c41e2e37933b04e6c3d6c0f94271a07d0ff6) Thanks [@brian-lou](https://github.com/brian-lou)! - Fix <GTProvider> wizard scan behavior
+
+## 2.1.7
+
+### Patch Changes
+
+- [#579](https://github.com/generaltranslation/gt/pull/579) [`a485533`](https://github.com/generaltranslation/gt/commit/a4855336dfe5242cfdb24fd2e981f86b0bffdf05) Thanks [@SamEggert](https://github.com/SamEggert)! - fix localize static urls, add baseDomain functionality
+
 ## 2.1.6
 
 ### Patch Changes

package/dist/cli/commands/translate.js

@@ -3,7 +3,6 @@ import { createFileMapping } from '../../formats/files/fileMapping.js';
 import { logError } from '../../console/logging.js';
 import { getStagedVersions } from '../../fs/config/updateVersions.js';
 import copyFile from '../../fs/copyFile.js';
-import localizeStaticImports from '../../utils/localizeStaticImports.js';
 import flattenJsonFiles from '../../utils/flattenJsonFiles.js';
 import localizeStaticUrls from '../../utils/localizeStaticUrls.js';
 import { noFilesError, noVersionIdError } from '../../console/index.js';
@@ -35,13 +34,13 @@ export async function handleDownload(options, settings) {
     await checkFileTranslations(stagedVersionData, settings.locales, options.timeout, (sourcePath, locale) => fileMapping[locale][sourcePath] ?? null, settings);
 }
 export async function postProcessTranslations(settings) {
-    // Localize static urls (/docs -> /[locale]/docs)
+    // Localize static urls (/docs -> /[locale]/docs) for non-default locales only
+    // Default locale is processed earlier in the flow in base.ts
     if (settings.options?.experimentalLocalizeStaticUrls) {
-        await localizeStaticUrls(settings);
-    }
-    // Localize static imports (/docs -> /[locale]/docs)
-    if (settings.options?.experimentalLocalizeStaticImports) {
-        await localizeStaticImports(settings);
+        const nonDefaultLocales = settings.locales.filter((locale) => locale !== settings.defaultLocale);
+        if (nonDefaultLocales.length > 0) {
+            await localizeStaticUrls(settings, nonDefaultLocales);
+        }
     }
     // Flatten json files into a single file
     if (settings.options?.experimentalFlattenJsonFiles) {

package/dist/config/generateSettings.js

@@ -104,7 +104,7 @@ export async function generateSettings(options, cwd = process.cwd()) {
     // For human review, always stage the project
     mergedOptions.stageTranslations = mergedOptions.stageTranslations ?? false;
     // Add publish if not provided
-    mergedOptions.publish = mergedOptions.publish ?? false;
+    mergedOptions.publish = (gtConfig.publish || options.publish) ?? false;
     // Populate src if not provided
     mergedOptions.src = mergedOptions.src || DEFAULT_SRC_PATTERNS;
     // Resolve all glob patterns in the files object

package/dist/next/parse/wrapContent.js

@@ -61,8 +61,22 @@ export async function wrapContentNext(options, pkg, errors, warnings) {
                 if (pkg === 'gt-next' &&
                     options.addGTProvider &&
                     isHtmlElement(path.node.openingElement)) {
-                    // Find the body element in the HTML children
-                    const bodyElement = path.node.children.find((child) => t.isJSXElement(child) && isBodyElement(child.openingElement));
+                    // Find the body element recursively in the HTML tree
+                    const findBodyElement = (children) => {
+                        for (const child of children) {
+                            if (t.isJSXElement(child) &&
+                                isBodyElement(child.openingElement)) {
+                                return child;
+                            }
+                            if (t.isJSXElement(child)) {
+                                const bodyInChild = findBodyElement(child.children);
+                                if (bodyInChild)
+                                    return bodyInChild;
+                            }
+                        }
+                        return null;
+                    };
+                    const bodyElement = findBodyElement(path.node.children);
                     if (!bodyElement) {
                         warnings.push(`File ${file} has a <html> tag without a <body> tag. Skipping GTProvider insertion.`);
                         return;

package/dist/react/jsx/utils/constants.d.ts

@@ -1,3 +1,6 @@
+export declare const MSG_TRANSLATION_HOOK = "msg";
+export declare const INLINE_TRANSLATION_HOOK = "useGT";
+export declare const INLINE_TRANSLATION_HOOK_ASYNC = "getGT";
 export declare const GT_TRANSLATION_FUNCS: string[];
 export declare const VARIABLE_COMPONENTS: string[];
 export declare const GT_ATTRIBUTES_WITH_SUGAR: string[];

package/dist/react/jsx/utils/constants.js

@@ -1,7 +1,11 @@
+export const MSG_TRANSLATION_HOOK = 'msg';
+export const INLINE_TRANSLATION_HOOK = 'useGT';
+export const INLINE_TRANSLATION_HOOK_ASYNC = 'getGT';
 // GT translation functions
 export const GT_TRANSLATION_FUNCS = [
-    'useGT',
-    'getGT',
+    INLINE_TRANSLATION_HOOK,
+    INLINE_TRANSLATION_HOOK_ASYNC,
+    MSG_TRANSLATION_HOOK,
     'T',
     'Var',
     'DateTime',

package/dist/react/jsx/utils/parseStringFunction.js

@@ -1,6 +1,6 @@
 import * as t from '@babel/types';
 import { isStaticExpression } from '../evaluateJsx.js';
-import { GT_ATTRIBUTES_WITH_SUGAR, mapAttributeName } from './constants.js';
+import { GT_ATTRIBUTES_WITH_SUGAR, MSG_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, mapAttributeName, } from './constants.js';
 import { warnNonStaticExpressionSync, warnNonStringSync, warnTemplateLiteralSync, warnAsyncUseGT, warnSyncGetGT, } from '../../../console/index.js';
 import generateModule from '@babel/generator';
 import traverseModule from '@babel/traverse';
@@ -22,7 +22,7 @@ import resolve from 'resolve';
  * - Metadata extraction from options object
  * - Error reporting for non-static expressions and template literals with expressions
  */
-function processTranslationCall(tPath, updates, errors, file) {
+function processTranslationCall(tPath, updates, errors, file, ignoreAdditionalData) {
     if (tPath.parent.type === 'CallExpression' &&
         tPath.parent.arguments.length > 0) {
         const arg = tPath.parent.arguments[0];
@@ -43,7 +43,7 @@ function processTranslationCall(tPath, updates, errors, file) {
                             if (!result.isStatic) {
                                 errors.push(warnNonStaticExpressionSync(file, attribute, generate(prop.value).code, `${prop.loc?.start?.line}:${prop.loc?.start?.column}`));
                             }
-                            if (result.isStatic && result.value) {
+                            if (result.isStatic && result.value && !ignoreAdditionalData) {
                                 // Map $id and $context to id and context
                                 metadata[mapAttributeName(attribute)] = result.value;
                             }
@@ -145,11 +145,11 @@ function resolveVariableAliases(scope, variableName, visited = new Set()) {
  * This covers both direct translation calls (t('hello')) and prop drilling
  * where the translation callback is passed to other functions (getData(t)).
  */
-function handleFunctionCall(tPath, updates, errors, file, importMap) {
+function handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAdditionalData) {
     if (tPath.parent.type === 'CallExpression' &&
         tPath.parent.callee === tPath.node) {
         // Direct translation call: t('hello')
-        processTranslationCall(tPath, updates, errors, file);
+        processTranslationCall(tPath, updates, errors, file, ignoreAdditionalData);
     }
     else if (tPath.parent.type === 'CallExpression' &&
         t.isExpression(tPath.node) &&
@@ -161,7 +161,7 @@ function handleFunctionCall(tPath, updates, errors, file, importMap) {
             const calleeBinding = tPath.scope.getBinding(callee.name);
             if (calleeBinding && calleeBinding.path.isFunction()) {
                 const functionPath = calleeBinding.path;
-                processFunctionIfMatches(callee.name, argIndex, functionPath.node, functionPath, updates, errors, file);
+                processFunctionIfMatches(callee.name, argIndex, functionPath.node, functionPath, updates, errors, file, ignoreAdditionalData);
             }
             // Handle arrow functions assigned to variables: const getData = (t) => {...}
             else if (calleeBinding &&
@@ -170,14 +170,14 @@ function handleFunctionCall(tPath, updates, errors, file, importMap) {
                 (t.isArrowFunctionExpression(calleeBinding.path.node.init) ||
                     t.isFunctionExpression(calleeBinding.path.node.init))) {
                 const initPath = calleeBinding.path.get('init');
-                processFunctionIfMatches(callee.name, argIndex, calleeBinding.path.node.init, initPath, updates, errors, file);
+                processFunctionIfMatches(callee.name, argIndex, calleeBinding.path.node.init, initPath, updates, errors, file, ignoreAdditionalData);
             }
             // If not found locally, check if it's an imported function
             else if (importMap.has(callee.name)) {
                 const importPath = importMap.get(callee.name);
                 const resolvedPath = resolveImportPath(file, importPath);
                 if (resolvedPath) {
-                    findFunctionInFile(resolvedPath, callee.name, argIndex, updates, errors);
+                    findFunctionInFile(resolvedPath, callee.name, argIndex, updates, errors, ignoreAdditionalData);
                 }
             }
         }
@@ -188,12 +188,12 @@ function handleFunctionCall(tPath, updates, errors, file, importMap) {
  * Validates the function has enough parameters and traces how the translation callback
  * is used within that function's body.
  */
-function processFunctionIfMatches(_functionName, argIndex, functionNode, functionPath, updates, errors, filePath) {
+function processFunctionIfMatches(_functionName, argIndex, functionNode, functionPath, updates, errors, filePath, ignoreAdditionalData) {
     if (functionNode.params.length > argIndex) {
         const param = functionNode.params[argIndex];
         const paramName = extractParameterName(param);
         if (paramName) {
-            findFunctionParameterUsage(functionPath, paramName, updates, errors, filePath);
+            findFunctionParameterUsage(functionPath, paramName, updates, errors, filePath, ignoreAdditionalData);
         }
     }
 }
@@ -205,7 +205,7 @@ function processFunctionIfMatches(_functionName, argIndex, functionNode, functio
  * Example: In function getInfo(t) { return t('hello'); }, this finds the t('hello') call.
  * Example: In function getData(t) { return getFooter(t); }, this finds and traces into getFooter.
  */
-function findFunctionParameterUsage(functionPath, parameterName, updates, errors, file) {
+function findFunctionParameterUsage(functionPath, parameterName, updates, errors, file, ignoreAdditionalData) {
     // Look for the function body and find all usages of the parameter
     if (functionPath.isFunction()) {
         const functionScope = functionPath.scope;
@@ -220,7 +220,7 @@ function findFunctionParameterUsage(functionPath, parameterName, updates, errors
             const binding = functionScope.bindings[name];
             if (binding) {
                 binding.referencePaths.forEach((refPath) => {
-                    handleFunctionCall(refPath, updates, errors, file, importMap);
+                    handleFunctionCall(refPath, updates, errors, file, importMap, ignoreAdditionalData);
                 });
             }
         });
@@ -299,7 +299,7 @@ function resolveImportPath(currentFile, importPath) {
  * - export function getInfo(t) { ... }
  * - const getInfo = (t) => { ... }
  */
-function findFunctionInFile(filePath, functionName, argIndex, updates, errors) {
+function findFunctionInFile(filePath, functionName, argIndex, updates, errors, ignoreAdditionalData) {
     try {
         const code = fs.readFileSync(filePath, 'utf8');
         const ast = parse(code, {
@@ -310,7 +310,7 @@ function findFunctionInFile(filePath, functionName, argIndex, updates, errors) {
             // Handle function declarations: function getInfo(t) { ... }
             FunctionDeclaration(path) {
                 if (path.node.id?.name === functionName) {
-                    processFunctionIfMatches(functionName, argIndex, path.node, path, updates, errors, filePath);
+                    processFunctionIfMatches(functionName, argIndex, path.node, path, updates, errors, filePath, ignoreAdditionalData);
                 }
             },
             // Handle variable declarations: const getInfo = (t) => { ... }
@@ -321,7 +321,7 @@ function findFunctionInFile(filePath, functionName, argIndex, updates, errors) {
                     (t.isArrowFunctionExpression(path.node.init) ||
                         t.isFunctionExpression(path.node.init))) {
                     const initPath = path.get('init');
-                    processFunctionIfMatches(functionName, argIndex, path.node.init, initPath, updates, errors, filePath);
+                    processFunctionIfMatches(functionName, argIndex, path.node.init, initPath, updates, errors, filePath, ignoreAdditionalData);
                 }
             },
         });
@@ -348,21 +348,33 @@ export function parseStrings(importName, originalName, path, updates, errors, fi
     const importMap = buildImportMap(path.scope.getProgramParent().path);
     const referencePaths = path.scope.bindings[importName]?.referencePaths || [];
     for (const refPath of referencePaths) {
-        // Find call expressions of useGT() / await getGT()
+        // Handle msg() calls directly without variable assignment
+        if (originalName === MSG_TRANSLATION_HOOK) {
+            const ignoreAdditionalData = true;
+            // Check if this is a direct call to msg('string')
+            if (refPath.parent.type === 'CallExpression' &&
+                refPath.parent.callee === refPath.node) {
+                processTranslationCall(refPath, updates, errors, file, ignoreAdditionalData);
+            }
+            continue;
+        }
+        // Handle useGT() and getGT() calls that need variable assignment
         const callExpr = refPath.findParent((p) => p.isCallExpression());
         if (callExpr) {
             // Get the parent, handling both await and non-await cases
             const parentPath = callExpr.parentPath;
             const parentFunction = refPath.getFunctionParent();
             const asyncScope = parentFunction?.node.async;
-            if (asyncScope && originalName === 'useGT') {
+            if (asyncScope && originalName === INLINE_TRANSLATION_HOOK) {
                 errors.push(warnAsyncUseGT(file, `${refPath.node.loc?.start?.line}:${refPath.node.loc?.start?.column}`));
                 return;
             }
-            else if (!asyncScope && originalName === 'getGT') {
+            else if (!asyncScope &&
+                originalName === INLINE_TRANSLATION_HOOK_ASYNC) {
                 errors.push(warnSyncGetGT(file, `${refPath.node.loc?.start?.line}:${refPath.node.loc?.start?.column}`));
                 return;
             }
+            const ignoreAdditionalData = false;
             const effectiveParent = parentPath?.node.type === 'AwaitExpression'
                 ? parentPath.parentPath
                 : parentPath;
@@ -372,10 +384,16 @@ export function parseStrings(importName, originalName, path, updates, errors, fi
                 const tFuncName = effectiveParent.node.id.name;
                 // Get the scope from the variable declaration
                 const variableScope = effectiveParent.scope;
-                const tReferencePaths = variableScope.bindings[tFuncName]?.referencePaths || [];
-                for (const tPath of tReferencePaths) {
-                    handleFunctionCall(tPath, updates, errors, file, importMap);
-                }
+                // Resolve all aliases of the translation function
+                // Example: translate -> [translate, t, a, b] for const t = translate; const a = t; const b = a;
+                const allTranslationNames = resolveVariableAliases(variableScope, tFuncName);
+                // Process references for all translation function names and their aliases
+                allTranslationNames.forEach((name) => {
+                    const tReferencePaths = variableScope.bindings[name]?.referencePaths || [];
+                    for (const tPath of tReferencePaths) {
+                        handleFunctionCall(tPath, updates, errors, file, importMap, ignoreAdditionalData);
+                    }
+                });
             }
         }
     }

package/dist/react/jsx/utils/validateStringFunction.js

@@ -1,4 +1,5 @@
 import { warnAsyncUseGT, warnSyncGetGT } from '../../../console/index.js';
+import { INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, } from './constants.js';
 /**
  * Validate useGT() / await getGT() calls
  * 1. Validates that the call does not violate the rules of React (no hooks in async functions)
@@ -12,13 +13,13 @@ export function validateStringFunction(localImportName, path, updates, errors, f
                 callPath.node.callee.name === localImportName) {
                 // Check the function scope
                 const functionScope = callPath.getFunctionParent();
-                if (originalImportName === 'useGT') {
+                if (originalImportName === INLINE_TRANSLATION_HOOK) {
                     // useGT should NOT be in an async function
                     if (functionScope && functionScope.node.async) {
                         errors.push(warnAsyncUseGT(file, `${callPath.node.loc?.start?.line}:${callPath.node.loc?.start?.column}`));
                     }
                 }
-                else if (originalImportName === 'getGT') {
+                else if (originalImportName === INLINE_TRANSLATION_HOOK_ASYNC) {
                     // getGT should be in an async function
                     if (!functionScope || !functionScope.node.async) {
                         errors.push(warnSyncGetGT(file, `${callPath.node.loc?.start?.line}:${callPath.node.loc?.start?.column}`));

package/dist/react/parse/createInlineUpdates.js

@@ -8,7 +8,7 @@ import { parseJSXElement } from '../jsx/utils/parseJsx.js';
 import { parseStrings } from '../jsx/utils/parseStringFunction.js';
 import { extractImportName } from '../jsx/utils/parseAst.js';
 import { logError } from '../../console/logging.js';
-import { GT_TRANSLATION_FUNCS } from '../jsx/utils/constants.js';
+import { GT_TRANSLATION_FUNCS, INLINE_TRANSLATION_HOOK, INLINE_TRANSLATION_HOOK_ASYNC, MSG_TRANSLATION_HOOK, } from '../jsx/utils/constants.js';
 import { matchFiles } from '../../fs/matchFiles.js';
 import { DEFAULT_SRC_PATTERNS } from '../../config/generateSettings.js';
 export async function createInlineUpdates(pkg, validate, filePatterns) {
@@ -38,7 +38,9 @@ export async function createInlineUpdates(pkg, validate, filePatterns) {
                 if (path.node.source.value.startsWith(pkg)) {
                     const importName = extractImportName(path.node, pkg, GT_TRANSLATION_FUNCS);
                     for (const name of importName) {
-                        if (name.original === 'useGT' || name.original === 'getGT') {
+                        if (name.original === INLINE_TRANSLATION_HOOK ||
+                            name.original === INLINE_TRANSLATION_HOOK_ASYNC ||
+                            name.original === MSG_TRANSLATION_HOOK) {
                             translationPaths.push({
                                 localName: name.local,
                                 path,
@@ -65,7 +67,9 @@ export async function createInlineUpdates(pkg, validate, filePatterns) {
                         if (parentPath.isVariableDeclaration()) {
                             const importName = extractImportName(parentPath.node, pkg, GT_TRANSLATION_FUNCS);
                             for (const name of importName) {
-                                if (name.original === 'useGT' || name.original === 'getGT') {
+                                if (name.original === INLINE_TRANSLATION_HOOK ||
+                                    name.original === INLINE_TRANSLATION_HOOK_ASYNC ||
+                                    name.original === MSG_TRANSLATION_HOOK) {
                                     translationPaths.push({
                                         localName: name.local,
                                         path: parentPath,

package/dist/types/index.d.ts

@@ -141,6 +141,7 @@ export type AdditionalOptions = {
     experimentalLocalizeStaticUrls?: boolean;
     experimentalHideDefaultLocale?: boolean;
     experimentalFlattenJsonFiles?: boolean;
+    baseDomain?: string;
 };
 export type JsonSchema = {
     preset?: 'mintlify';

package/dist/utils/localizeStaticUrls.d.ts

@@ -12,4 +12,8 @@ import { Settings } from '../types/index.js';
  * - Support more file types
  * - Support more complex paths
  */
-export default function localizeStaticUrls(settings: Settings): Promise<void>;
+export default function localizeStaticUrls(settings: Settings, targetLocales?: string[]): Promise<void>;
+/**
+ * Main URL transformation function that delegates to specific scenarios
+ */
+export declare function transformUrlPath(originalUrl: string, patternHead: string, targetLocale: string, defaultLocale: string, hideDefaultLocale: boolean): string | null;

package/dist/utils/localizeStaticUrls.js

@@ -21,19 +21,24 @@ const { isMatch } = micromatch;
  * - Support more file types
  * - Support more complex paths
  */
-export default async function localizeStaticUrls(settings) {
+export default async function localizeStaticUrls(settings, targetLocales) {
     if (!settings.files ||
         (Object.keys(settings.files.placeholderPaths).length === 1 &&
             settings.files.placeholderPaths.gt)) {
         return;
     }
     const { resolvedPaths: sourceFiles } = settings.files;
-    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales, settings.defaultLocale);
+    // Use filtered locales if provided, otherwise use all locales
+    const locales = targetLocales || settings.locales;
+    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales, // Always use all locales for mapping, filter later
+    settings.defaultLocale);
     // Process all file types at once with a single call
     const processPromises = [];
     // First, process default locale files (from source files)
     // This is needed because they might not be in the fileMapping if they're not being translated
-    if (!fileMapping[settings.defaultLocale]) {
+    // Only process default locale if it's in the target locales filter
+    if (!fileMapping[settings.defaultLocale] &&
+        locales.includes(settings.defaultLocale)) {
         const defaultLocaleFiles = [];
         // Collect all .md and .mdx files from sourceFiles
         if (sourceFiles.md) {
@@ -47,16 +52,20 @@ export default async function localizeStaticUrls(settings) {
                 // Get file content
                 const fileContent = await fs.promises.readFile(filePath, 'utf8');
                 // Localize the file using default locale
-                const localizedFile = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, settings.defaultLocale, // Process as default locale
-                settings.options?.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls);
-                // Write the localized file back to the same path
-                await fs.promises.writeFile(filePath, localizedFile);
+                const result = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, settings.defaultLocale, // Process as default locale
+                settings.options?.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls, settings.options?.baseDomain);
+                // Only write the file if there were changes
+                if (result.hasChanges) {
+                    await fs.promises.writeFile(filePath, result.content);
+                }
             }));
             processPromises.push(defaultPromise);
         }
     }
     // Then process all other locales from fileMapping
-    const mappingPromises = Object.entries(fileMapping).map(async ([locale, filesMap]) => {
+    const mappingPromises = Object.entries(fileMapping)
+        .filter(([locale, filesMap]) => locales.includes(locale)) // Filter by target locales
+        .map(async ([locale, filesMap]) => {
         // Get all files that are md or mdx
         const targetFiles = Object.values(filesMap).filter((path) => path.endsWith('.md') || path.endsWith('.mdx'));
         // Replace the placeholder path with the target path
@@ -64,9 +73,11 @@ export default async function localizeStaticUrls(settings) {
             // Get file content
             const fileContent = await fs.promises.readFile(filePath, 'utf8');
             // Localize the file (handles both URLs and hrefs in single AST pass)
-            const localizedFile = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, locale, settings.options?.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls);
-            // Write the localized file to the target path
-            await fs.promises.writeFile(filePath, localizedFile);
+            const result = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, locale, settings.options?.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls, settings.options?.baseDomain);
+            // Only write the file if there were changes
+            if (result.hasChanges) {
+                await fs.promises.writeFile(filePath, result.content);
+            }
         }));
     });
     processPromises.push(...mappingPromises);
@@ -75,21 +86,28 @@ export default async function localizeStaticUrls(settings) {
 /**
  * Determines if a URL should be processed based on pattern matching
  */
-function shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale) {
-    // Skip absolute URLs (http://, https://, //, etc.)
-    if (originalUrl.includes(':')) {
-        return false;
-    }
+function shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale, baseDomain) {
     const patternWithoutSlash = patternHead.replace(/\/$/, '');
+    // Handle absolute URLs with baseDomain
+    let urlToCheck = originalUrl;
+    if (baseDomain && originalUrl.startsWith(baseDomain)) {
+        urlToCheck = originalUrl.substring(baseDomain.length);
+    }
     if (targetLocale === defaultLocale) {
         // For default locale processing, check if URL contains the pattern
-        return originalUrl.includes(patternWithoutSlash);
+        return urlToCheck.includes(patternWithoutSlash);
     }
     else {
         // For non-default locales, check if URL starts with pattern
-        return originalUrl.startsWith(patternWithoutSlash);
+        return urlToCheck.startsWith(patternWithoutSlash);
     }
 }
+/**
+ * Determines if a URL should be processed based on the base domain
+ */
+function shouldProcessAbsoluteUrl(originalUrl, baseDomain) {
+    return originalUrl.startsWith(baseDomain);
+}
 /**
  * Checks if a URL should be excluded based on exclusion patterns
  */
@@ -98,102 +116,79 @@ function isUrlExcluded(originalUrl, exclude, defaultLocale) {
     return excludePatterns.some((pattern) => isMatch(originalUrl, pattern));
 }
 /**
- * Transforms URL for default locale processing
- */
-function transformDefaultLocaleUrl(originalUrl, patternHead, defaultLocale, hideDefaultLocale) {
-    if (hideDefaultLocale) {
-        // Remove locale from URLs that have it: '/docs/en/file' -> '/docs/file'
-        if (originalUrl.includes(`/${defaultLocale}/`)) {
-            return originalUrl.replace(`/${defaultLocale}/`, '/');
-        }
-        else if (originalUrl.endsWith(`/${defaultLocale}`)) {
-            return originalUrl.replace(`/${defaultLocale}`, '');
-        }
-        return null; // URL doesn't have default locale
-    }
-    else {
-        // Add locale to URLs that don't have it: '/docs/file' -> '/docs/en/file'
-        if (originalUrl.includes(`/${defaultLocale}/`) ||
-            originalUrl.endsWith(`/${defaultLocale}`)) {
-            return null; // Already has default locale
-        }
-        if (originalUrl.startsWith(patternHead)) {
-            const pathAfterHead = originalUrl.slice(patternHead.length);
-            if (pathAfterHead) {
-                return `${patternHead}${defaultLocale}/${pathAfterHead}`;
-            }
-            else {
-                return `${patternHead.replace(/\/$/, '')}/${defaultLocale}`;
-            }
-        }
-        return null; // URL doesn't match pattern
-    }
-}
-/**
- * Transforms URL for non-default locale processing with hideDefaultLocale=true
+ * Main URL transformation function that delegates to specific scenarios
  */
-function transformNonDefaultLocaleUrlWithHidden(originalUrl, patternHead, targetLocale, defaultLocale) {
-    // Check if already localized
-    if (originalUrl.startsWith(`${patternHead}${targetLocale}/`) ||
-        originalUrl === `${patternHead}${targetLocale}`) {
+export function transformUrlPath(originalUrl, patternHead, targetLocale, defaultLocale, hideDefaultLocale) {
+    const originalPathArray = originalUrl
+        .split('/')
+        .filter((path) => path !== '');
+    const patternHeadArray = patternHead.split('/').filter((path) => path !== '');
+    // check if the pattern head matches the original path
+    if (!checkIfPathMatchesPattern(originalPathArray, patternHeadArray)) {
         return null;
     }
-    // Replace default locale with target locale
-    const expectedPathWithDefaultLocale = `${patternHead}${defaultLocale}`;
-    if (originalUrl.startsWith(`${expectedPathWithDefaultLocale}/`) ||
-        originalUrl === expectedPathWithDefaultLocale) {
-        return originalUrl.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
-    }
-    // Handle exact pattern match
-    if (originalUrl === patternHead.replace(/\/$/, '')) {
-        return `${patternHead.replace(/\/$/, '')}/${targetLocale}`;
+    if (patternHeadArray.length > originalPathArray.length) {
+        return null; // Pattern is longer than the URL path
     }
-    // Add target locale to URL without any locale
-    const pathAfterHead = originalUrl.slice(originalUrl.startsWith(patternHead) ? patternHead.length : 0);
-    return pathAfterHead
-        ? `${patternHead}${targetLocale}/${pathAfterHead}`
-        : `${patternHead}${targetLocale}`;
-}
-/**
- * Transforms URL for non-default locale processing with hideDefaultLocale=false
- */
-function transformNonDefaultLocaleUrl(originalUrl, patternHead, targetLocale, defaultLocale) {
-    const expectedPathWithLocale = `${patternHead}${defaultLocale}`;
-    if (originalUrl.startsWith(`${expectedPathWithLocale}/`) ||
-        originalUrl === expectedPathWithLocale) {
-        // Replace existing default locale with target locale
-        return originalUrl.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
-    }
-    else if (originalUrl.startsWith(patternHead)) {
-        // Add target locale to URL that doesn't have any locale
-        const pathAfterHead = originalUrl.slice(patternHead.length);
-        if (pathAfterHead) {
-            return `${patternHead}${targetLocale}/${pathAfterHead}`;
+    let result = null;
+    if (targetLocale === defaultLocale) {
+        if (hideDefaultLocale) {
+            // check if default locale is already present
+            if (originalPathArray?.[patternHeadArray.length] !== defaultLocale) {
+                return null;
+            }
+            // remove default locale
+            const newPathArray = [
+                ...originalPathArray.slice(0, patternHeadArray.length),
+                ...originalPathArray.slice(patternHeadArray.length + 1),
+            ];
+            result = newPathArray.join('/');
         }
         else {
-            return `${patternHead.replace(/\/$/, '')}/${targetLocale}`;
+            // check if default locale is already present
+            if (originalPathArray?.[patternHeadArray.length] === defaultLocale) {
+                return null;
+            }
+            // insert default locale
+            const newPathArray = [
+                ...originalPathArray.slice(0, patternHeadArray.length),
+                defaultLocale,
+                ...originalPathArray.slice(patternHeadArray.length),
+            ];
+            result = newPathArray.join('/');
         }
     }
-    return null; // URL doesn't match pattern
-}
-/**
- * Main URL transformation function that delegates to specific scenarios
- */
-function transformUrlPath(originalUrl, patternHead, targetLocale, defaultLocale, hideDefaultLocale) {
-    if (targetLocale === defaultLocale) {
-        return transformDefaultLocaleUrl(originalUrl, patternHead, defaultLocale, hideDefaultLocale);
-    }
     else if (hideDefaultLocale) {
-        return transformNonDefaultLocaleUrlWithHidden(originalUrl, patternHead, targetLocale, defaultLocale);
+        const newPathArray = [
+            ...originalPathArray.slice(0, patternHeadArray.length),
+            targetLocale,
+            ...originalPathArray.slice(patternHeadArray.length),
+        ];
+        result = newPathArray.join('/');
     }
     else {
-        return transformNonDefaultLocaleUrl(originalUrl, patternHead, targetLocale, defaultLocale);
+        // check default locale
+        if (originalPathArray?.[patternHeadArray.length] !== defaultLocale) {
+            return null;
+        }
+        // replace default locale with target locale
+        const newPathArray = [...originalPathArray];
+        newPathArray[patternHeadArray.length] = targetLocale;
+        result = newPathArray.join('/');
     }
+    // check for leading and trailing slashes
+    if (originalUrl.startsWith('/')) {
+        result = '/' + result;
+    }
+    if (originalUrl.endsWith('/')) {
+        result = result + '/';
+    }
+    return result;
 }
 /**
  * AST-based transformation for MDX files using remark-mdx
  */
-function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', exclude = []) {
+function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', exclude = [], baseDomain) {
     const transformedUrls = [];
     if (!pattern.startsWith('/')) {
         pattern = '/' + pattern;
@@ -240,13 +235,32 @@ function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLo
         return {
             content: mdxContent,
             hasChanges: false,
-            transformedUrls: [],
+            transformedUrls,
         };
     }
     // Helper function to transform URL based on pattern
     const transformUrl = (originalUrl, linkType) => {
         // Check if URL should be processed
-        if (!shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale)) {
+        if (!shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale, baseDomain)) {
+            return null;
+        }
+        // Skip absolute URLs (http://, https://, //, etc.)
+        if (baseDomain && shouldProcessAbsoluteUrl(originalUrl, baseDomain)) {
+            // Get everything after the base domain
+            const afterDomain = originalUrl.substring(baseDomain.length);
+            const transformedPath = transformUrlPath(afterDomain, patternHead, targetLocale, defaultLocale, hideDefaultLocale);
+            if (!transformedPath) {
+                return null;
+            }
+            transformedUrls.push({
+                originalPath: originalUrl,
+                newPath: transformedPath,
+                type: linkType,
+            });
+            return transformedPath ? baseDomain + transformedPath : null;
+        }
+        // Exclude colon-prefixed URLs (http://, https://, //, etc.)
+        if (originalUrl.split('?')[0].includes(':')) {
             return null;
         }
         // Transform the URL based on locale and configuration
@@ -381,8 +395,23 @@ function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLo
 }
 // AST-based transformation for MDX files using remark
 function localizeStaticUrlsForFile(file, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', // eg /docs/[locale] or /[locale]
-exclude = []) {
+exclude = [], baseDomain) {
     // Use AST-based transformation for MDX files
-    const result = transformMdxUrls(file, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude);
-    return result.content;
+    return transformMdxUrls(file, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude, baseDomain || '');
+}
+function cleanPath(path) {
+    let cleanedPath = path.startsWith('/') ? path.slice(1) : path;
+    cleanedPath = cleanedPath.endsWith('/')
+        ? cleanedPath.slice(0, -1)
+        : cleanedPath;
+    return cleanedPath;
+}
+function checkIfPathMatchesPattern(originalUrlArray, patternHeadArray) {
+    // check if the pattern head matches the original path
+    for (let i = 0; i < patternHeadArray.length; i++) {
+        if (patternHeadArray[i] !== originalUrlArray?.[i]) {
+            return false;
+        }
+    }
+    return true;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.1.6",
+  "version": "2.1.8-alpha.1",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [