gtx-cli 2.3.4 → 2.3.6-alpha.1

package/dist/utils/packageManager.js

@@ -1,269 +0,0 @@
-// This file is MIT licensed and was adapted from https://github.com/getsentry/sentry-wizard/blob/master/src/utils/package-manager.ts and https://github.com/getsentry/sentry-wizard/blob/master/src/utils/clack/index.ts
-import * as fs from 'fs';
-import * as path from 'path';
-import { getPackageJson, updatePackageJson } from './packageJson.js';
-import { promptSelect } from '../console/logging.js';
-export class NoPackageManagerError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'NoPackageManagerError';
-    }
-}
-export const BUN = {
-    id: 'bun',
-    name: 'bun',
-    label: 'Bun',
-    installCommand: 'add',
-    installAllCommand: 'bun install',
-    buildCommand: 'bun run build',
-    runScriptCommand: 'bun run',
-    flags: '',
-    forceInstallFlag: '--force',
-    devDependencyFlag: '--dev',
-    detect: (cwd) => ['bun.lockb', 'bun.lock'].some((lockFile) => {
-        try {
-            return fs.existsSync(path.join(cwd, lockFile));
-        }
-        catch (e) {
-            return false;
-        }
-    }),
-    addOverride: async (pkgName, pkgVersion) => {
-        const packageDotJson = await getPackageJson();
-        if (!packageDotJson) {
-            return;
-        }
-        const overrides = packageDotJson.overrides || {};
-        await updatePackageJson({
-            ...packageDotJson,
-            overrides: {
-                ...overrides,
-                [pkgName]: pkgVersion,
-            },
-        });
-    },
-};
-export const DENO = {
-    id: 'deno',
-    name: 'deno',
-    label: 'Deno',
-    installCommand: 'install',
-    installAllCommand: 'deno install',
-    buildCommand: 'deno task build',
-    runScriptCommand: 'deno task',
-    flags: '',
-    forceInstallFlag: '--force',
-    devDependencyFlag: '--dev',
-    registry: 'npm',
-    detect: (cwd) => {
-        try {
-            return fs.existsSync(path.join(cwd, 'deno.lock'));
-        }
-        catch (e) {
-            return false;
-        }
-    },
-    addOverride: async (pkgName, pkgVersion) => {
-        const packageDotJson = await getPackageJson();
-        if (!packageDotJson) {
-            return;
-        }
-        const overrides = packageDotJson.overrides || {};
-        await updatePackageJson({
-            ...packageDotJson,
-            overrides: {
-                ...overrides,
-                [pkgName]: pkgVersion,
-            },
-        });
-    },
-};
-export const YARN_V1 = {
-    id: 'yarn_v1',
-    name: 'yarn',
-    label: 'Yarn V1',
-    installCommand: 'add',
-    installAllCommand: 'yarn install',
-    buildCommand: 'yarn build',
-    runScriptCommand: 'yarn',
-    flags: '--ignore-workspace-root-check',
-    forceInstallFlag: '--force',
-    devDependencyFlag: '--dev',
-    detect: (cwd) => {
-        try {
-            return fs
-                .readFileSync(path.join(cwd, 'yarn.lock'), 'utf-8')
-                .slice(0, 500)
-                .includes('yarn lockfile v1');
-        }
-        catch (e) {
-            return false;
-        }
-    },
-    addOverride: async (pkgName, pkgVersion) => {
-        const packageDotJson = await getPackageJson();
-        if (!packageDotJson) {
-            return;
-        }
-        const resolutions = packageDotJson.resolutions || {};
-        await updatePackageJson({
-            ...packageDotJson,
-            resolutions: {
-                ...resolutions,
-                [pkgName]: pkgVersion,
-            },
-        });
-    },
-};
-/** YARN V2/3/4 */
-export const YARN_V2 = {
-    id: 'yarn_v2',
-    name: 'yarn',
-    label: 'Yarn V2/3/4',
-    installCommand: 'add',
-    installAllCommand: 'yarn install',
-    buildCommand: 'yarn build',
-    runScriptCommand: 'yarn',
-    flags: '',
-    forceInstallFlag: '--force',
-    devDependencyFlag: '--dev',
-    detect: (cwd) => {
-        try {
-            return fs
-                .readFileSync(path.join(cwd, 'yarn.lock'), 'utf-8')
-                .slice(0, 500)
-                .includes('__metadata');
-        }
-        catch (e) {
-            return false;
-        }
-    },
-    addOverride: async (pkgName, pkgVersion) => {
-        const packageDotJson = await getPackageJson();
-        if (!packageDotJson) {
-            return;
-        }
-        const resolutions = packageDotJson.resolutions || {};
-        await updatePackageJson({
-            ...packageDotJson,
-            resolutions: {
-                ...resolutions,
-                [pkgName]: pkgVersion,
-            },
-        });
-    },
-};
-export const PNPM = {
-    id: 'pnpm',
-    name: 'pnpm',
-    label: 'PNPM',
-    installCommand: 'add',
-    installAllCommand: 'pnpm install',
-    buildCommand: 'pnpm build',
-    runScriptCommand: 'pnpm',
-    flags: '--ignore-workspace-root-check',
-    forceInstallFlag: '--force',
-    devDependencyFlag: '--save-dev',
-    detect: (cwd) => {
-        try {
-            return fs.existsSync(path.join(cwd, 'pnpm-lock.yaml'));
-        }
-        catch (e) {
-            return false;
-        }
-    },
-    addOverride: async (pkgName, pkgVersion) => {
-        const packageDotJson = await getPackageJson();
-        if (!packageDotJson) {
-            return;
-        }
-        const pnpm = packageDotJson.pnpm || {};
-        const overrides = pnpm.overrides || {};
-        await updatePackageJson({
-            ...packageDotJson,
-            pnpm: {
-                ...pnpm,
-                overrides: {
-                    ...overrides,
-                    [pkgName]: pkgVersion,
-                },
-            },
-        });
-    },
-};
-export const NPM = {
-    id: 'npm',
-    name: 'npm',
-    label: 'NPM',
-    installCommand: 'install',
-    installAllCommand: 'npm ci',
-    buildCommand: 'npm run build',
-    runScriptCommand: 'npm run',
-    flags: '',
-    forceInstallFlag: '--force',
-    devDependencyFlag: '--save-dev',
-    detect: (cwd) => {
-        try {
-            return fs.existsSync(path.join(cwd, 'package-lock.json'));
-        }
-        catch (e) {
-            return false;
-        }
-    },
-    addOverride: async (pkgName, pkgVersion) => {
-        const packageDotJson = await getPackageJson();
-        if (!packageDotJson) {
-            return;
-        }
-        const overrides = packageDotJson.overrides || {};
-        await updatePackageJson({
-            ...packageDotJson,
-            overrides: {
-                ...overrides,
-                [pkgName]: pkgVersion,
-            },
-        });
-    },
-};
-export const packageManagers = [NPM, YARN_V1, YARN_V2, PNPM, BUN, DENO];
-export function _detectPackageManger(cwd) {
-    const foundPackageMangers = packageManagers.filter((packageManager) => packageManager.detect(cwd));
-    // Only consider a package manager detected if we found exactly one.
-    // If we find more than one, we should not make any assumptions.
-    if (foundPackageMangers.length === 1) {
-        return foundPackageMangers[0];
-    }
-    return null;
-}
-// Get the package manager for the current project
-// Uses a global cache to avoid prompting the user multiple times
-export async function getPackageManager(cwd = process.cwd(), specifiedPackageManager, errorIfNotFound = false) {
-    const globalWizard = global;
-    if (globalWizard._gt_wizard_cached_package_manager) {
-        return globalWizard._gt_wizard_cached_package_manager;
-    }
-    if (specifiedPackageManager) {
-        const packageManager = packageManagers.find((packageManager) => packageManager.id === specifiedPackageManager);
-        if (packageManager) {
-            globalWizard._gt_wizard_cached_package_manager = packageManager;
-            return packageManager;
-        }
-    }
-    const detectedPackageManager = _detectPackageManger(cwd);
-    if (detectedPackageManager) {
-        globalWizard._gt_wizard_cached_package_manager = detectedPackageManager;
-        return detectedPackageManager;
-    }
-    if (errorIfNotFound) {
-        throw new NoPackageManagerError('No package manager found');
-    }
-    const selectedPackageManager = await promptSelect({
-        message: 'Please select your package manager.',
-        options: packageManagers.map((packageManager) => ({
-            value: packageManager,
-            label: packageManager.label,
-        })),
-    });
-    globalWizard._gt_wizard_cached_package_manager = selectedPackageManager;
-    return selectedPackageManager;
-}

package/dist/utils/processAnchorIds.d.ts

@@ -1,6 +0,0 @@
-import { Settings } from '../types/index.js';
-/**
- * Processes all translated MD/MDX files to add explicit anchor IDs
- * This preserves navigation links when headings are translated
- */
-export default function processAnchorIds(settings: Settings): Promise<void>;

package/dist/utils/processAnchorIds.js

@@ -1,47 +0,0 @@
-import { addExplicitAnchorIds, extractHeadingInfo, } from './addExplicitAnchorIds.js';
-import { readFile } from '../fs/findFilepath.js';
-import { createFileMapping } from '../formats/files/fileMapping.js';
-import * as fs from 'fs';
-/**
- * Processes all translated MD/MDX files to add explicit anchor IDs
- * This preserves navigation links when headings are translated
- */
-export default async function processAnchorIds(settings) {
-    if (!settings.files)
-        return;
-    const { resolvedPaths, placeholderPaths, transformPaths } = settings.files;
-    const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
-    // Process each locale's translated files
-    const processPromises = Object.entries(fileMapping)
-        .filter(([locale, filesMap]) => locale !== settings.defaultLocale) // Skip default locale
-        .map(async ([locale, filesMap]) => {
-        // Get all translated files that are md or mdx
-        const translatedFiles = Object.values(filesMap).filter((path) => path && (path.endsWith('.md') || path.endsWith('.mdx')));
-        for (const translatedPath of translatedFiles) {
-            try {
-                // Check if translated file exists before processing
-                if (!fs.existsSync(translatedPath)) {
-                    continue;
-                }
-                // Find the corresponding source file
-                const sourcePath = Object.keys(filesMap).find((key) => filesMap[key] === translatedPath);
-                if (!sourcePath) {
-                    continue;
-                }
-                // Extract heading info from source file
-                const sourceContent = readFile(sourcePath);
-                const sourceHeadingMap = extractHeadingInfo(sourceContent);
-                // Read translated file and apply anchor IDs
-                const translatedContent = readFile(translatedPath);
-                const result = addExplicitAnchorIds(translatedContent, sourceHeadingMap, settings, sourcePath, translatedPath);
-                if (result.hasChanges) {
-                    fs.writeFileSync(translatedPath, result.content, 'utf8');
-                }
-            }
-            catch (error) {
-                console.warn(`Failed to process IDs for ${translatedPath}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-    });
-    await Promise.all(processPromises);
-}

package/dist/utils/sanitizeFileContent.d.ts

@@ -1,6 +0,0 @@
-/**
- * Processes content to escape curl commands within tick marks and existing escape strings
- * @param content - The content to process
- * @returns the processed content with escaped curl commands
- */
-export default function sanitizeFileContent(content: string): string;

package/dist/utils/sanitizeFileContent.js

@@ -1,29 +0,0 @@
-/**
- * Processes content to escape curl commands within tick marks and existing escape strings
- * @param content - The content to process
- * @returns the processed content with escaped curl commands
- */
-export default function sanitizeFileContent(content) {
-    const ESCAPE_STRING = '_GT_INTERNAL_ESCAPE';
-    const allTickMarkRegex = /`([^`]*)`/g;
-    let processedContent = content;
-    // First, escape any existing tick marks followed by _GT_INTERNAL_ESCAPE
-    // This protects pre-existing escapes
-    processedContent = processedContent.replace(new RegExp('`' + ESCAPE_STRING, 'g'), '`' + ESCAPE_STRING + ESCAPE_STRING);
-    // Then find ALL tick mark pairs and process them individually
-    // This approach is more reliable than negative lookahead with modified content
-    processedContent = processedContent.replace(allTickMarkRegex, (match, innerContent) => {
-        // Skip if this already starts with our escape string (protected or already processed)
-        if (innerContent.startsWith(ESCAPE_STRING)) {
-            return match;
-        }
-        // Check if the content contains a curl command
-        if (/\bcurl\b/i.test(innerContent)) {
-            // Insert escape string after opening tick
-            return '`' + ESCAPE_STRING + innerContent + '`';
-        }
-        // Return original match if no curl command found
-        return match;
-    });
-    return processedContent;
-}

package/dist/utils/validateMdx.d.ts

@@ -1,10 +0,0 @@
-/**
- * Validates if an MDX file content can be parsed as a valid AST
- * @param content - The MDX file content to validate
- * @param filePath - The file path for error reporting
- * @returns object with isValid boolean and optional error message
- */
-export declare function isValidMdx(content: string, filePath: string): {
-    isValid: boolean;
-    error?: string;
-};

package/dist/utils/validateMdx.js

@@ -1,25 +0,0 @@
-import { unified } from 'unified';
-import remarkParse from 'remark-parse';
-import remarkMdx from 'remark-mdx';
-import remarkFrontmatter from 'remark-frontmatter';
-/**
- * Validates if an MDX file content can be parsed as a valid AST
- * @param content - The MDX file content to validate
- * @param filePath - The file path for error reporting
- * @returns object with isValid boolean and optional error message
- */
-export function isValidMdx(content, filePath) {
-    try {
-        const parseProcessor = unified()
-            .use(remarkParse)
-            .use(remarkFrontmatter, ['yaml', 'toml'])
-            .use(remarkMdx);
-        const ast = parseProcessor.parse(content);
-        parseProcessor.runSync(ast);
-        return { isValid: true };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return { isValid: false, error: errorMessage };
-    }
-}