gtx-cli 2.3.4 → 2.3.6-alpha.1

package/dist/utils/localizeStaticUrls.js

@@ -1,432 +0,0 @@
-import * as fs from 'fs';
-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 remarkStringify from 'remark-stringify';
-import { visit } from 'unist-util-visit';
-import escapeHtmlInTextNodes from 'gt-remark';
-const { isMatch } = micromatch;
-/**
- * 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 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;
-    // 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
-    // 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) {
-            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 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)
-        .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
-        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 (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);
-            }
-        }));
-    });
-    processPromises.push(...mappingPromises);
-    await Promise.all(processPromises);
-}
-/**
- * Determines if a URL should be processed based on pattern matching
- */
-function shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale, baseDomain) {
-    // Check fragment-only URLs like "#id-name"
-    if (/^\s*#/.test(originalUrl)) {
-        return false;
-    }
-    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 urlToCheck.includes(patternWithoutSlash);
-    }
-    else {
-        // For non-default locales, check if URL starts with pattern
-        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
- */
-function isUrlExcluded(originalUrl, exclude, defaultLocale) {
-    const excludePatterns = exclude.map((p) => p.replace(/\[locale\]/g, defaultLocale));
-    return excludePatterns.some((pattern) => isMatch(originalUrl, pattern));
-}
-/**
- * Main URL transformation function that delegates to specific scenarios
- */
-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;
-    }
-    if (patternHeadArray.length > originalPathArray.length) {
-        return null; // Pattern is longer than the URL path
-    }
-    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 {
-            // 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('/');
-        }
-    }
-    else if (hideDefaultLocale) {
-        const newPathArray = [
-            ...originalPathArray.slice(0, patternHeadArray.length),
-            targetLocale,
-            ...originalPathArray.slice(patternHeadArray.length),
-        ];
-        result = newPathArray.join('/');
-    }
-    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;
-    }
-    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) {
-    const transformedUrls = [];
-    if (!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,
-                transformedUrls: [],
-            };
-        }
-    }
-    else {
-        // For non-default locales, use the original logic
-        if (!mdxContent.includes(patternHead.replace(/\/$/, ''))) {
-            return {
-                content: mdxContent,
-                hasChanges: false,
-                transformedUrls: [],
-            };
-        }
-    }
-    // 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 (error) {
-        console.warn(`Failed to parse MDX content: ${error instanceof Error ? error.message : String(error)}`);
-        console.warn('Returning original content unchanged due to parsing error.');
-        return {
-            content: mdxContent,
-            hasChanges: false,
-            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, 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
-        const newUrl = transformUrlPath(originalUrl, patternHead, targetLocale, defaultLocale, hideDefaultLocale);
-        if (!newUrl) {
-            return null;
-        }
-        // Check exclusions
-        if (isUrlExcluded(originalUrl, exclude, defaultLocale)) {
-            return null;
-        }
-        transformedUrls.push({
-            originalPath: originalUrl,
-            newPath: newUrl,
-            type: linkType,
-        });
-        return newUrl;
-    };
-    // Visit markdown link nodes: [text](url)
-    visit(processedAst, 'link', (node) => {
-        if (node.url) {
-            const newUrl = transformUrl(node.url, 'markdown');
-            if (newUrl) {
-                node.url = newUrl;
-            }
-        }
-    });
-    // Visit JSX/HTML elements for href attributes: <a href="url"> or <Card href="url">
-    visit(processedAst, ['mdxJsxFlowElement', 'mdxJsxTextElement'], (node) => {
-        const jsxNode = node;
-        if (jsxNode.attributes) {
-            for (const attr of jsxNode.attributes) {
-                if (attr.type === 'mdxJsxAttribute' &&
-                    attr.name === 'href' &&
-                    attr.value) {
-                    // Handle MdxJsxAttribute with string or MdxJsxAttributeValueExpression
-                    const hrefValue = typeof attr.value === 'string' ? attr.value : attr.value.value;
-                    if (typeof hrefValue === 'string') {
-                        const newUrl = transformUrl(hrefValue, 'href');
-                        if (newUrl) {
-                            if (typeof attr.value === 'string') {
-                                attr.value = newUrl;
-                            }
-                            else {
-                                attr.value.value = newUrl;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    });
-    // Visit raw JSX nodes for href attributes in JSX strings
-    visit(processedAst, 'jsx', (node) => {
-        if (node.value && typeof node.value === 'string') {
-            const jsxContent = node.value;
-            // Use regex to find href attributes in the JSX string
-            const hrefRegex = /href\s*=\s*["']([^"']+)["']/g;
-            let match;
-            const replacements = [];
-            // Reset regex lastIndex to avoid issues with global flag
-            hrefRegex.lastIndex = 0;
-            while ((match = hrefRegex.exec(jsxContent)) !== null) {
-                const originalHref = match[1];
-                const newUrl = transformUrl(originalHref, 'href');
-                if (newUrl) {
-                    // Store replacement info
-                    const oldHrefAttr = match[0]; // The full match like 'href="/quickstart"'
-                    const quote = oldHrefAttr.includes('"') ? '"' : "'";
-                    const newHrefAttr = `href=${quote}${newUrl}${quote}`;
-                    replacements.push({
-                        start: match.index,
-                        end: match.index + oldHrefAttr.length,
-                        oldHrefAttr,
-                        newHrefAttr,
-                    });
-                }
-            }
-            // Apply replacements in reverse order (from end to start) to avoid position shifts
-            if (replacements.length > 0) {
-                let newJsxContent = jsxContent;
-                replacements
-                    .sort((a, b) => b.start - a.start)
-                    .forEach(({ start, end, newHrefAttr }) => {
-                    newJsxContent =
-                        newJsxContent.slice(0, start) +
-                            newHrefAttr +
-                            newJsxContent.slice(end);
-                });
-                node.value = newJsxContent;
-            }
-        }
-    });
-    // Convert the modified AST back to MDX string
-    let content;
-    try {
-        const stringifyProcessor = unified()
-            .use(remarkFrontmatter, ['yaml', 'toml'])
-            .use(remarkMdx)
-            .use(escapeHtmlInTextNodes)
-            .use(remarkStringify, {
-            handlers: {
-                // Handler to prevent escaping (avoids '&lt;' -> '\&lt;')
-                text(node) {
-                    return node.value;
-                },
-            },
-        });
-        const outTree = stringifyProcessor.runSync(processedAst);
-        content = stringifyProcessor.stringify(outTree);
-    }
-    catch (error) {
-        console.warn(`Failed to stringify MDX content: ${error instanceof Error ? error.message : String(error)}`);
-        console.warn('Returning original content unchanged due to stringify error.');
-        return {
-            content: mdxContent,
-            hasChanges: false,
-            transformedUrls: [],
-        };
-    }
-    // Handle newline formatting to match original input
-    if (content.endsWith('\n') && !mdxContent.endsWith('\n')) {
-        content = content.slice(0, -1);
-    }
-    // Preserve leading newlines from original content
-    if (mdxContent.startsWith('\n') && !content.startsWith('\n')) {
-        content = '\n' + content;
-    }
-    return {
-        content,
-        hasChanges: transformedUrls.length > 0,
-        transformedUrls,
-    };
-}
-// AST-based transformation for MDX files using remark
-function localizeStaticUrlsForFile(file, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', // eg /docs/[locale] or /[locale]
-exclude = [], baseDomain) {
-    // 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;
-}

package/dist/utils/packageInfo.d.ts

@@ -1,3 +0,0 @@
-export declare function getPackageInfo(packageName: string): Promise<{
-    version: string;
-} | undefined>;

package/dist/utils/packageInfo.js

@@ -1,17 +0,0 @@
-import { execSync } from 'child_process';
-export async function getPackageInfo(packageName) {
-    try {
-        const output = execSync(`npm list -g ${packageName}`, {
-            encoding: 'utf8',
-            stdio: 'pipe',
-        });
-        const match = output.match(new RegExp(`${packageName}@([\\d\\.\\w-]+)`));
-        if (match && match[1]) {
-            return { version: match[1] };
-        }
-        return undefined;
-    }
-    catch (error) {
-        return undefined;
-    }
-}

package/dist/utils/packageJson.d.ts

@@ -1,6 +0,0 @@
-export declare function searchForPackageJson(cwd?: string): Promise<Record<string, any> | null>;
-export declare function getPackageJson(cwd?: string): Promise<Record<string, any> | null>;
-export declare function getCLIVersion(): string;
-export declare function updatePackageJson(packageJson: Record<string, any>, cwd?: string): Promise<void>;
-export declare function isPackageInstalled(packageName: string, packageJson: Record<string, any>, asDevDependency?: boolean, checkBoth?: boolean): boolean;
-export declare function getPackageVersion(packageName: string, packageJson: Record<string, any>): string | undefined;

package/dist/utils/packageJson.js

@@ -1,76 +0,0 @@
-import { logError } from '../console/logging.js';
-import chalk from 'chalk';
-import path from 'node:path';
-import fs from 'node:fs';
-import { fromPackageRoot } from '../fs/getPackageResource.js';
-// search for package.json such that we can run init in non-js projects
-export async function searchForPackageJson(cwd = process.cwd()) {
-    // Get the current working directory (where the CLI is being run)
-    const packageJsonPath = path.join(cwd, 'package.json');
-    // Check if package.json exists
-    if (!fs.existsSync(packageJsonPath)) {
-        return null;
-    }
-    try {
-        return JSON.parse(await fs.promises.readFile(packageJsonPath, 'utf8'));
-    }
-    catch (error) {
-        return null;
-    }
-}
-export async function getPackageJson(cwd = process.cwd()) {
-    const packageJsonPath = path.join(cwd, 'package.json');
-    // Check if package.json exists
-    if (!fs.existsSync(packageJsonPath)) {
-        return null;
-    }
-    try {
-        return JSON.parse(await fs.promises.readFile(packageJsonPath, 'utf8'));
-    }
-    catch (error) {
-        return null;
-    }
-}
-export function getCLIVersion() {
-    const packageJsonPath = fromPackageRoot('package.json');
-    if (!fs.existsSync(packageJsonPath)) {
-        return 'unknown';
-    }
-    try {
-        return JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')).version;
-    }
-    catch (error) {
-        return 'unknown';
-    }
-}
-export async function updatePackageJson(packageJson, cwd = process.cwd()) {
-    try {
-        await fs.promises.writeFile(path.join(cwd, 'package.json'), JSON.stringify(packageJson, null, 2));
-    }
-    catch (error) {
-        logError(chalk.red('Error updating package.json: ' + String(error)));
-        process.exit(1);
-    }
-}
-// check if a package is installed in the package.json file
-export function isPackageInstalled(packageName, packageJson, asDevDependency = false, checkBoth = false) {
-    const dependencies = checkBoth
-        ? {
-            ...packageJson.devDependencies,
-            ...packageJson.dependencies,
-        }
-        : asDevDependency
-            ? packageJson.devDependencies
-            : packageJson.dependencies;
-    if (!dependencies) {
-        return false;
-    }
-    return dependencies[packageName] !== undefined;
-}
-export function getPackageVersion(packageName, packageJson) {
-    const dependencies = {
-        ...packageJson.dependencies,
-        ...packageJson.devDependencies,
-    };
-    return dependencies[packageName] ?? undefined;
-}

package/dist/utils/packageManager.d.ts

@@ -1,28 +0,0 @@
-export interface PackageManager {
-    id: string;
-    name: string;
-    label: string;
-    installCommand: string;
-    installAllCommand: string;
-    buildCommand: string;
-    runScriptCommand: string;
-    flags: string;
-    forceInstallFlag: string;
-    devDependencyFlag: string;
-    registry?: string;
-    detect: (cwd: string) => boolean;
-    addOverride: (pkgName: string, pkgVersion: string) => Promise<void>;
-}
-export declare class NoPackageManagerError extends Error {
-    constructor(message: string);
-}
-export declare const BUN: PackageManager;
-export declare const DENO: PackageManager;
-export declare const YARN_V1: PackageManager;
-/** YARN V2/3/4 */
-export declare const YARN_V2: PackageManager;
-export declare const PNPM: PackageManager;
-export declare const NPM: PackageManager;
-export declare const packageManagers: PackageManager[];
-export declare function _detectPackageManger(cwd: string): PackageManager | null;
-export declare function getPackageManager(cwd?: string, specifiedPackageManager?: string, errorIfNotFound?: boolean): Promise<PackageManager>;