gtx-cli 2.1.6 → 2.1.7

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # gtx-cli
 
+## 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/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.7",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [