gtx-cli 2.1.5-alpha.6 → 2.1.6

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # gtx-cli
 
+## 2.1.6
+
+### Patch Changes
+
+- [#584](https://github.com/generaltranslation/gt/pull/584) [`fd3d958`](https://github.com/generaltranslation/gt/commit/fd3d958dab3d14a7f1f9b49c5c49fba191077a57) Thanks [@brian-lou](https://github.com/brian-lou)! - Fix version
+
+## 2.1.5
+
+### Patch Changes
+
+- [#580](https://github.com/generaltranslation/gt/pull/580) [`9b05fda`](https://github.com/generaltranslation/gt/commit/9b05fda9959f9e24491c02f357bc2a2c49ba0276) Thanks [@brian-lou](https://github.com/brian-lou)! - Update API schema, combine files and JSX translation endpoints
+
+- Updated dependencies [[`9b05fda`](https://github.com/generaltranslation/gt/commit/9b05fda9959f9e24491c02f357bc2a2c49ba0276)]:
+  - generaltranslation@7.4.1
+
 ## 2.1.5
 
 ### Patch Changes

package/dist/cli/base.js

@@ -17,7 +17,6 @@ import { upload } from '../formats/files/upload.js';
 import { attachTranslateFlags } from './flags.js';
 import { handleStage } from './commands/stage.js';
 import { handleDownload, handleTranslate, postProcessTranslations, } from './commands/translate.js';
-import localizeStaticUrls from '../utils/localizeStaticUrls.js';
 import updateConfig from '../fs/config/updateConfig.js';
 export class BaseCLI {
     library;
@@ -79,19 +78,11 @@ export class BaseCLI {
         const settings = await generateSettings(initOptions);
         if (!settings.stageTranslations) {
             const results = await handleStage(initOptions, settings, this.library, false);
-            // Process default locale static URLs first, before translations
-            if (settings.options?.experimentalLocalizeStaticUrls) {
-                await localizeStaticUrls(settings, [settings.defaultLocale]);
-            }
             if (results) {
                 await handleTranslate(initOptions, settings, results);
             }
         }
         else {
-            // Process default locale static URLs first, before downloading translations
-            if (settings.options?.experimentalLocalizeStaticUrls) {
-                await localizeStaticUrls(settings, [settings.defaultLocale]);
-            }
             await handleDownload(initOptions, settings);
         }
         await postProcessTranslations(settings);

package/dist/cli/commands/translate.js

@@ -35,13 +35,9 @@ 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) for non-default locales only
-    // Default locale is processed earlier in the flow in base.ts
+    // Localize static urls (/docs -> /[locale]/docs)
     if (settings.options?.experimentalLocalizeStaticUrls) {
-        const nonDefaultLocales = settings.locales.filter(locale => locale !== settings.defaultLocale);
-        if (nonDefaultLocales.length > 0) {
-            await localizeStaticUrls(settings, nonDefaultLocales);
-        }
+        await localizeStaticUrls(settings);
     }
     // Localize static imports (/docs -> /[locale]/docs)
     if (settings.options?.experimentalLocalizeStaticImports) {

package/dist/types/index.d.ts

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

package/dist/utils/localizeStaticUrls.d.ts

@@ -12,8 +12,4 @@ import { Settings } from '../types/index.js';
  * - Support more file types
  * - Support more complex paths
  */
-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;
+export default function localizeStaticUrls(settings: Settings): Promise<void>;

package/dist/utils/localizeStaticUrls.js

@@ -21,24 +21,19 @@ const { isMatch } = micromatch;
  * - Support more file types
  * - Support more complex paths
  */
-export default async function localizeStaticUrls(settings, targetLocales) {
+export default async function localizeStaticUrls(settings) {
     if (!settings.files ||
         (Object.keys(settings.files.placeholderPaths).length === 1 &&
             settings.files.placeholderPaths.gt)) {
         return;
     }
     const { resolvedPaths: sourceFiles } = settings.files;
-    // 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);
+    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales, 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
-    // Only process default locale if it's in the target locales filter
-    if (!fileMapping[settings.defaultLocale] &&
-        locales.includes(settings.defaultLocale)) {
+    if (!fileMapping[settings.defaultLocale]) {
         const defaultLocaleFiles = [];
         // Collect all .md and .mdx files from sourceFiles
         if (sourceFiles.md) {
@@ -52,20 +47,16 @@ export default async function localizeStaticUrls(settings, targetLocales) {
                 // Get file content
                 const fileContent = await fs.promises.readFile(filePath, 'utf8');
                 // Localize the file using default locale
-                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);
-                }
+                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);
             }));
             processPromises.push(defaultPromise);
         }
     }
     // Then process all other locales from fileMapping
-    const mappingPromises = Object.entries(fileMapping)
-        .filter(([locale, filesMap]) => locales.includes(locale)) // Filter by target locales
-        .map(async ([locale, filesMap]) => {
+    const mappingPromises = Object.entries(fileMapping).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
@@ -73,11 +64,9 @@ export default async function localizeStaticUrls(settings, targetLocales) {
             // Get file content
             const fileContent = await fs.promises.readFile(filePath, 'utf8');
             // Localize the file (handles both URLs and hrefs in single AST pass)
-            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);
-            }
+            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);
         }));
     });
     processPromises.push(...mappingPromises);
@@ -86,28 +75,21 @@ export default async function localizeStaticUrls(settings, targetLocales) {
 /**
  * Determines if a URL should be processed based on pattern matching
  */
-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);
+function shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale) {
+    // Skip absolute URLs (http://, https://, //, etc.)
+    if (originalUrl.includes(':')) {
+        return false;
     }
+    const patternWithoutSlash = patternHead.replace(/\/$/, '');
     if (targetLocale === defaultLocale) {
         // For default locale processing, check if URL contains the pattern
-        return urlToCheck.includes(patternWithoutSlash);
+        return originalUrl.includes(patternWithoutSlash);
     }
     else {
         // For non-default locales, check if URL starts with pattern
-        return urlToCheck.startsWith(patternWithoutSlash);
+        return originalUrl.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
  */
@@ -116,79 +98,102 @@ function isUrlExcluded(originalUrl, exclude, defaultLocale) {
     return excludePatterns.some((pattern) => isMatch(originalUrl, pattern));
 }
 /**
- * Main URL transformation function that delegates to specific scenarios
+ * Transforms URL for default locale processing
  */
-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)) {
+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
+ */
+function transformNonDefaultLocaleUrlWithHidden(originalUrl, patternHead, targetLocale, defaultLocale) {
+    // Check if already localized
+    if (originalUrl.startsWith(`${patternHead}${targetLocale}/`) ||
+        originalUrl === `${patternHead}${targetLocale}`) {
         return null;
     }
-    if (patternHeadArray.length > originalPathArray.length) {
-        return null; // Pattern is longer than the URL path
+    // Replace default locale with target locale
+    const expectedPathWithDefaultLocale = `${patternHead}${defaultLocale}`;
+    if (originalUrl.startsWith(`${expectedPathWithDefaultLocale}/`) ||
+        originalUrl === expectedPathWithDefaultLocale) {
+        return originalUrl.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
     }
-    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('/');
+    // Handle exact pattern match
+    if (originalUrl === patternHead.replace(/\/$/, '')) {
+        return `${patternHead.replace(/\/$/, '')}/${targetLocale}`;
+    }
+    // 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}`;
         }
         else {
-            // 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 `${patternHead.replace(/\/$/, '')}/${targetLocale}`;
         }
     }
+    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) {
-        const newPathArray = [
-            ...originalPathArray.slice(0, patternHeadArray.length),
-            targetLocale,
-            ...originalPathArray.slice(patternHeadArray.length),
-        ];
-        result = newPathArray.join('/');
+        return transformNonDefaultLocaleUrlWithHidden(originalUrl, patternHead, targetLocale, defaultLocale);
     }
     else {
-        // 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;
+        return transformNonDefaultLocaleUrl(originalUrl, patternHead, targetLocale, defaultLocale);
     }
-    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 = [], baseDomain) {
+function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', exclude = []) {
     const transformedUrls = [];
     if (!pattern.startsWith('/')) {
         pattern = '/' + pattern;
@@ -241,18 +246,7 @@ function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLo
     // Helper function to transform URL based on pattern
     const transformUrl = (originalUrl, linkType) => {
         // Check if URL should be processed
-        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);
-            return transformedPath ? baseDomain + transformedPath : null;
-        }
-        // Exclude colon-prefixed URLs (http://, https://, //, etc.)
-        if (originalUrl.split('?')[0].includes(':')) {
+        if (!shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale)) {
             return null;
         }
         // Transform the URL based on locale and configuration
@@ -387,23 +381,8 @@ 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 = [], baseDomain) {
+exclude = []) {
     // Use AST-based transformation for MDX files
-    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;
+    const result = transformMdxUrls(file, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude);
+    return result.content;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.1.5-alpha.6",
+  "version": "2.1.6",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -87,7 +87,7 @@
     "esbuild": "^0.25.4",
     "fast-glob": "^3.3.3",
     "form-data": "^4.0.4",
-    "generaltranslation": "^7.4.1-alpha.2",
+    "generaltranslation": "^7.4.1",
     "json-pointer": "^0.6.2",
     "jsonpath-plus": "^10.3.0",
     "jsonpointer": "^5.0.1",