gtx-cli 2.6.31 → 2.7.0

package/dist/utils/localizeStaticImports.js

@@ -1,397 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { createFileMapping } from '../formats/files/fileMapping.js';
-import micromatch from 'micromatch';
-import { unified } from 'unified';
-import remarkParse from 'remark-parse';
-import remarkMdx from 'remark-mdx';
-import remarkFrontmatter from 'remark-frontmatter';
-import { visit } from 'unist-util-visit';
-const { isMatch } = micromatch;
-/**
- * Localizes static imports in content files.
- * Currently only supported for md and mdx files. (/docs/ -> /[locale]/docs/)
- * @param settings - The settings object containing the project configuration.
- * @returns void
- *
- * @TODO This is an experimental feature, and only works in very specific cases. This needs to be improved before
- * it can be enabled by default.
- *
- * Before this becomes a non-experimental feature, we need to:
- * - Support more file types
- * - Support more complex paths
- */
-export default async function localizeStaticImports(settings, includeFiles) {
-    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);
-    // 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] && !includeFiles) {
-        const defaultLocaleFiles = [];
-        // Collect all .md and .mdx files from sourceFiles
-        if (sourceFiles.md) {
-            defaultLocaleFiles.push(...sourceFiles.md);
-        }
-        if (sourceFiles.mdx) {
-            defaultLocaleFiles.push(...sourceFiles.mdx);
-        }
-        if (defaultLocaleFiles.length > 0) {
-            const defaultPromise = Promise.all(defaultLocaleFiles.map(async (filePath) => {
-                // Check if file exists before processing
-                if (!fs.existsSync(filePath)) {
-                    return;
-                }
-                // Get file content
-                const fileContent = await fs.promises.readFile(filePath, 'utf8');
-                // Localize the file using default locale
-                const localizedFile = localizeStaticImportsForFile(fileContent, settings.defaultLocale, settings.defaultLocale, // Process as default locale
-                settings.options?.docsHideDefaultLocaleImport || false, settings.options?.docsImportPattern, settings.options?.excludeStaticImports, filePath, settings.options);
-                // 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).map(async ([locale, filesMap]) => {
-        // Get all files that are md or mdx
-        const targetFiles = Object.values(filesMap).filter((p) => (p.endsWith('.md') || p.endsWith('.mdx')) &&
-            (!includeFiles || includeFiles.has(p)));
-        // Replace the placeholder path with the target path
-        await Promise.all(targetFiles.map(async (filePath) => {
-            // Check if file exists before processing
-            if (!fs.existsSync(filePath)) {
-                return;
-            }
-            // Get file content
-            const fileContent = await fs.promises.readFile(filePath, 'utf8');
-            // Localize the file
-            const localizedFile = localizeStaticImportsForFile(fileContent, settings.defaultLocale, locale, settings.options?.docsHideDefaultLocaleImport || false, settings.options?.docsImportPattern, settings.options?.excludeStaticImports, filePath, settings.options);
-            // Write the localized file to the target path
-            await fs.promises.writeFile(filePath, localizedFile);
-        }));
-    });
-    processPromises.push(...mappingPromises);
-    await Promise.all(processPromises);
-}
-/**
- * Determines if an import path should be processed based on pattern matching
- */
-function shouldProcessImportPath(importPath, patternHead, targetLocale, defaultLocale) {
-    const patternWithoutSlash = patternHead.replace(/\/$/, '');
-    if (targetLocale === defaultLocale) {
-        // For default locale processing, check if path contains the pattern
-        return importPath.includes(patternWithoutSlash);
-    }
-    else {
-        // For non-default locales, check if path starts with pattern
-        return importPath.includes(patternWithoutSlash);
-    }
-}
-/**
- * Checks if an import path should be excluded based on exclusion patterns
- */
-function isImportPathExcluded(importPath, exclude, defaultLocale) {
-    const excludePatterns = exclude.map((p) => p.replace(/\[locale\]/g, defaultLocale));
-    return excludePatterns.some((pattern) => isMatch(importPath, pattern));
-}
-/**
- * Transforms import path for default locale processing
- */
-function transformDefaultLocaleImportPath(fullPath, patternHead, defaultLocale, hideDefaultLocale) {
-    if (hideDefaultLocale) {
-        // Remove locale from imports that have it: '/snippets/en/file.mdx' -> '/snippets/file.mdx'
-        if (fullPath.includes(`/${defaultLocale}/`)) {
-            return fullPath.replace(`/${defaultLocale}/`, '/');
-        }
-        else if (fullPath.endsWith(`/${defaultLocale}`)) {
-            return fullPath.replace(`/${defaultLocale}`, '');
-        }
-        return null; // Path doesn't have default locale
-    }
-    else {
-        // Add locale to imports that don't have it: '/snippets/file.mdx' -> '/snippets/en/file.mdx'
-        if (fullPath.includes(`/${defaultLocale}/`) ||
-            fullPath.endsWith(`/${defaultLocale}`)) {
-            return null; // Already has default locale
-        }
-        if (fullPath.startsWith(patternHead)) {
-            const pathAfterHead = fullPath.slice(patternHead.length);
-            if (pathAfterHead) {
-                return `${patternHead}${defaultLocale}/${pathAfterHead}`;
-            }
-            else {
-                return `${patternHead.replace(/\/$/, '')}/${defaultLocale}`;
-            }
-        }
-        return null; // Path doesn't match pattern
-    }
-}
-/**
- * Transforms import path for non-default locale processing with hideDefaultLocale=true
- */
-function transformNonDefaultLocaleImportPathWithHidden(fullPath, patternHead, targetLocale, defaultLocale) {
-    // Check if already localized
-    if (fullPath.startsWith(`${patternHead}${targetLocale}/`) ||
-        fullPath === `${patternHead}${targetLocale}`) {
-        return null;
-    }
-    // Replace default locale with target locale
-    const expectedPathWithDefaultLocale = `${patternHead}${defaultLocale}`;
-    if (fullPath.startsWith(`${expectedPathWithDefaultLocale}/`) ||
-        fullPath === expectedPathWithDefaultLocale) {
-        return fullPath.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
-    }
-    // Handle exact pattern match
-    if (fullPath === patternHead.replace(/\/$/, '')) {
-        return `${patternHead.replace(/\/$/, '')}/${targetLocale}`;
-    }
-    // Add target locale to path without any locale
-    const pathAfterHead = fullPath.slice(patternHead.length);
-    return pathAfterHead
-        ? `${patternHead}${targetLocale}/${pathAfterHead}`
-        : `${patternHead}${targetLocale}`;
-}
-/**
- * Transforms import path for non-default locale processing with hideDefaultLocale=false
- */
-function transformNonDefaultLocaleImportPath(fullPath, patternHead, targetLocale, defaultLocale) {
-    // If already localized to target, skip
-    const expectedPathWithTarget = `${patternHead}${targetLocale}`;
-    if (fullPath.startsWith(`${expectedPathWithTarget}/`) ||
-        fullPath === expectedPathWithTarget) {
-        return null;
-    }
-    const expectedPathWithLocale = `${patternHead}${defaultLocale}`;
-    if (fullPath.startsWith(`${expectedPathWithLocale}/`) ||
-        fullPath === expectedPathWithLocale) {
-        // Replace existing default locale with target locale
-        return fullPath.replace(`${patternHead}${defaultLocale}`, `${patternHead}${targetLocale}`);
-    }
-    else if (fullPath.startsWith(patternHead)) {
-        // Add target locale to path that doesn't have any locale
-        const pathAfterHead = fullPath.slice(patternHead.length);
-        if (pathAfterHead) {
-            return `${patternHead}${targetLocale}/${pathAfterHead}`;
-        }
-        else {
-            return `${patternHead.replace(/\/$/, '')}/${targetLocale}`;
-        }
-    }
-    return null; // Path doesn't match pattern
-}
-/**
- * Main import path transformation function that delegates to specific scenarios
- */
-function transformImportPath(fullPath, patternHead, targetLocale, defaultLocale, hideDefaultLocale, currentFilePath, projectRoot = process.cwd(), // fallback if not provided
-rewrites) {
-    // Apply explicit rewrites first (e.g., Docusaurus @site/docs -> @site/i18n/[locale]/...)
-    if (rewrites && rewrites.length > 0) {
-        const localeMap = {
-            '[locale]': targetLocale,
-            '[defaultLocale]': defaultLocale,
-        };
-        for (const { match, replace } of rewrites) {
-            const resolvedMatch = match.replace(/\[locale\]|\[defaultLocale\]/g, (token) => localeMap[token] || token);
-            if (fullPath.startsWith(resolvedMatch)) {
-                const remainder = fullPath.slice(resolvedMatch.length);
-                const resolvedReplace = replace.replace(/\[locale\]|\[defaultLocale\]/g, (token) => localeMap[token] || token);
-                let newPath;
-                if (resolvedReplace.endsWith('/')) {
-                    newPath = `${resolvedReplace}${remainder.replace(/^\//, '')}`;
-                }
-                else if (remainder.startsWith('/')) {
-                    newPath = `${resolvedReplace}${remainder}`;
-                }
-                else {
-                    newPath = `${resolvedReplace}/${remainder}`;
-                }
-                return newPath;
-            }
-        }
-    }
-    let newPath;
-    if (targetLocale === defaultLocale) {
-        newPath = transformDefaultLocaleImportPath(fullPath, patternHead, defaultLocale, hideDefaultLocale);
-    }
-    else if (hideDefaultLocale) {
-        newPath = transformNonDefaultLocaleImportPathWithHidden(fullPath, patternHead, targetLocale, defaultLocale);
-    }
-    else {
-        newPath = transformNonDefaultLocaleImportPath(fullPath, patternHead, targetLocale, defaultLocale);
-    }
-    if (!newPath)
-        return null;
-    if (currentFilePath) {
-        let resolvedPath;
-        if (newPath.startsWith('/')) {
-            // Interpret as project-root relative
-            resolvedPath = path.join(projectRoot, newPath.replace(/^\//, ''));
-        }
-        else {
-            // Relative to current file
-            const currentDir = path.dirname(currentFilePath);
-            resolvedPath = path.resolve(currentDir, newPath);
-        }
-        if (!fs.existsSync(resolvedPath)) {
-            return null;
-        }
-    }
-    return newPath;
-}
-/**
- * AST-based transformation for MDX files using remark-mdx
- */
-function transformMdxImports(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', exclude = [], currentFilePath, options) {
-    const transformedImports = [];
-    // Don't auto-prefix relative patterns that start with . or ..
-    if (!pattern.startsWith('/') && !pattern.startsWith('.')) {
-        pattern = '/' + pattern;
-    }
-    const patternHead = pattern.split('[locale]')[0];
-    // Quick check: if the file doesn't contain the pattern, skip expensive AST parsing
-    // For default locale processing, we also need to check if content might need adjustment
-    if (targetLocale === defaultLocale) {
-        // For default locale files, we always need to check as we're looking for either:
-        // - paths without locale (when hideDefaultLocale=false)
-        // - paths with default locale (when hideDefaultLocale=true)
-        const patternWithoutSlash = patternHead.replace(/\/$/, '');
-        if (!mdxContent.includes(patternWithoutSlash)) {
-            return {
-                content: mdxContent,
-                hasChanges: false,
-                transformedImports: [],
-            };
-        }
-    }
-    else {
-        // For non-default locales, use the original logic
-        if (!mdxContent.includes(patternHead.replace(/\/$/, ''))) {
-            return {
-                content: mdxContent,
-                hasChanges: false,
-                transformedImports: [],
-            };
-        }
-    }
-    // Parse the MDX content into an AST
-    let processedAst;
-    try {
-        const parseProcessor = unified()
-            .use(remarkParse)
-            .use(remarkFrontmatter, ['yaml', 'toml'])
-            .use(remarkMdx);
-        const ast = parseProcessor.parse(mdxContent);
-        processedAst = parseProcessor.runSync(ast);
-    }
-    catch {
-        return transformImportsStringFallback(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude, currentFilePath, options);
-    }
-    let content = mdxContent;
-    // Visit only mdxjsEsm nodes (import/export statements) to collect replacements
-    visit(processedAst, 'mdxjsEsm', (node) => {
-        if (node.value && node.value.includes(patternHead.replace(/\/$/, ''))) {
-            // Find import lines that need transformation
-            const lines = node.value.split('\n');
-            lines.forEach((line) => {
-                // Only process import lines that match our pattern
-                if (!line.trim().startsWith('import ')) {
-                    return;
-                }
-                // Check if this line should be processed
-                if (!shouldProcessImportPath(line, patternHead, targetLocale, defaultLocale)) {
-                    return;
-                }
-                // Extract the path from the import statement
-                const quotes = ['"', "'", '`'];
-                for (const quote of quotes) {
-                    // Try both with and without trailing slash
-                    let startPattern = `${quote}${patternHead}`;
-                    let startIndex = line.indexOf(startPattern);
-                    // If pattern has trailing slash but path doesn't, try without slash
-                    if (startIndex === -1 && patternHead.endsWith('/')) {
-                        const patternWithoutSlash = patternHead.slice(0, -1);
-                        startPattern = `${quote}${patternWithoutSlash}`;
-                        startIndex = line.indexOf(startPattern);
-                    }
-                    if (startIndex === -1)
-                        continue;
-                    const pathStart = startIndex + 1; // After the quote
-                    const pathEnd = line.indexOf(quote, pathStart);
-                    if (pathEnd === -1)
-                        continue;
-                    const fullPath = line.slice(pathStart, pathEnd);
-                    // Transform the import path
-                    const newPath = transformImportPath(fullPath, patternHead, targetLocale, defaultLocale, hideDefaultLocale, currentFilePath, process.cwd(), options?.docsImportRewrites);
-                    if (!newPath) {
-                        continue; // No transformation needed
-                    }
-                    // Check exclusions
-                    if (isImportPathExcluded(fullPath, exclude, defaultLocale)) {
-                        continue;
-                    }
-                    // Apply the transformation to the original content
-                    // Simply replace the import path with the new path
-                    content = content.replace(`${quote}${fullPath}${quote}`, `${quote}${newPath}${quote}`);
-                    transformedImports.push({ originalPath: fullPath, newPath });
-                    break;
-                }
-            });
-        }
-    });
-    return {
-        content,
-        hasChanges: transformedImports.length > 0,
-        transformedImports,
-    };
-}
-/**
- * String-based fallback for import localization when MDX parsing fails (e.g., on .md files)
- */
-function transformImportsStringFallback(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', exclude = [], currentFilePath, options) {
-    const transformedImports = [];
-    if (!pattern.startsWith('/') && !pattern.startsWith('.')) {
-        pattern = '/' + pattern;
-    }
-    const patternHead = pattern.split('[locale]')[0];
-    let content = mdxContent;
-    const importRegex = /import\s+[^'"]*['"]([^'"]+)['"]\s*;?/g;
-    let match;
-    while ((match = importRegex.exec(mdxContent)) !== null) {
-        const fullMatch = match[0];
-        const importPath = match[1];
-        if (!shouldProcessImportPath(importPath, patternHead, targetLocale, defaultLocale)) {
-            continue;
-        }
-        if (isImportPathExcluded(importPath, exclude, defaultLocale)) {
-            continue;
-        }
-        const newPath = transformImportPath(importPath, patternHead, targetLocale, defaultLocale, hideDefaultLocale, currentFilePath, process.cwd(), options?.docsImportRewrites);
-        if (!newPath)
-            continue;
-        const updatedImport = fullMatch.replace(importPath, newPath);
-        content = content.replace(fullMatch, updatedImport);
-        transformedImports.push({ originalPath: importPath, newPath });
-    }
-    return {
-        content,
-        hasChanges: transformedImports.length > 0,
-        transformedImports,
-    };
-}
-/**
- * AST-based transformation for MDX files only
- */
-function localizeStaticImportsForFile(file, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', // eg /docs/[locale] or /[locale]
-exclude = [], currentFilePath, options) {
-    // For MDX files, use AST-based transformation
-    const result = transformMdxImports(file, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude, currentFilePath, options);
-    return result.content;
-}

package/dist/utils/localizeStaticUrls.d.ts

@@ -1,19 +0,0 @@
-import { Settings } from '../types/index.js';
-/**
- * Localizes static urls in content files.
- * Currently only supported for md and mdx files. (/docs/ -> /[locale]/docs/)
- * @param settings - The settings object containing the project configuration.
- * @returns void
- *
- * @TODO This is an experimental feature, and only works in very specific cases. This needs to be improved before
- * it can be enabled by default.
- *
- * Before this becomes a non-experimental feature, we need to:
- * - Support more file types
- * - Support more complex paths
- */
-export default function localizeStaticUrls(settings: Settings, targetLocales?: string[], includeFiles?: Set<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;