gtx-cli 2.3.6-alpha.2 → 2.3.6

package/dist/utils/addExplicitAnchorIds.js

@@ -0,0 +1,260 @@
+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 { logWarning } from '../console/logging.js';
+import escapeHtmlInTextNodes from 'gt-remark';
+/**
+ * Generates a slug from heading text
+ */
+function generateSlug(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\w\s-]/g, '') // Remove special chars except spaces and hyphens
+        .trim()
+        .replace(/\s+/g, '-') // Replace spaces with hyphens
+        .replace(/-+/g, '-') // Replace multiple hyphens with single hyphen
+        .replace(/^-|-$/g, ''); // Remove leading/trailing hyphens
+}
+/**
+ * Extracts text content from heading nodes
+ */
+function extractHeadingText(heading) {
+    let text = '';
+    visit(heading, ['text', 'inlineCode'], (node) => {
+        if ('value' in node && typeof node.value === 'string') {
+            text += node.value;
+        }
+    });
+    return text;
+}
+/**
+ * Checks if a heading is already wrapped in a div with id
+ */
+function hasExplicitId(heading, ast) {
+    const lastChild = heading.children[heading.children.length - 1];
+    if (lastChild?.type === 'text') {
+        return /(\{#[^}]+\}|\[[^\]]+\])$/.test(lastChild.value);
+    }
+    return false;
+}
+/**
+ * Extracts heading information from content (read-only, no modifications)
+ */
+export function extractHeadingInfo(mdxContent) {
+    const headings = [];
+    // 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)}`);
+        return [];
+    }
+    let position = 0;
+    visit(processedAst, 'heading', (heading) => {
+        const headingText = extractHeadingText(heading);
+        if (headingText) {
+            const slug = generateSlug(headingText);
+            headings.push({
+                text: headingText,
+                level: heading.depth,
+                slug,
+                position: position++,
+            });
+        }
+    });
+    return headings;
+}
+/**
+ * Applies anchor IDs to translated content based on source heading mapping
+ */
+export function addExplicitAnchorIds(translatedContent, sourceHeadingMap, settings, sourcePath, translatedPath) {
+    const addedIds = [];
+    const useDivWrapping = settings?.options?.experimentalAddHeaderAnchorIds === 'mintlify';
+    // Extract headings from translated content
+    const translatedHeadings = extractHeadingInfo(translatedContent);
+    // Pre-processing validation: check if header counts match
+    if (sourceHeadingMap.length !== translatedHeadings.length) {
+        const sourceFile = sourcePath
+            ? `Source file: ${sourcePath}`
+            : 'Source file';
+        const translatedFile = translatedPath
+            ? `translated file: ${translatedPath}`
+            : 'translated file';
+        logWarning(`Header count mismatch detected! ${sourceFile} has ${sourceHeadingMap.length} headers but ${translatedFile} has ${translatedHeadings.length} headers. ` +
+            `This likely means your source file was edited after translation was requested, causing a mismatch between ` +
+            `the number of headers in your source file vs the translated file. Please re-translate this file to resolve the issue.`);
+    }
+    // Create ID mapping based on positional matching
+    const idMappings = new Map();
+    sourceHeadingMap.forEach((sourceHeading, index) => {
+        const translatedHeading = translatedHeadings[index];
+        // Match by position and level for safety
+        if (translatedHeading && translatedHeading.level === sourceHeading.level) {
+            idMappings.set(index, sourceHeading.slug);
+            addedIds.push({
+                heading: translatedHeading.text,
+                id: sourceHeading.slug,
+            });
+        }
+    });
+    if (idMappings.size === 0) {
+        return {
+            content: translatedContent,
+            hasChanges: false,
+            addedIds: [],
+        };
+    }
+    // Apply IDs to translated content
+    let content;
+    if (useDivWrapping) {
+        content = applyDivWrappedIds(translatedContent, translatedHeadings, idMappings);
+    }
+    else {
+        content = applyInlineIds(translatedContent, idMappings);
+    }
+    return {
+        content,
+        hasChanges: addedIds.length > 0,
+        addedIds,
+    };
+}
+/**
+ * Adds inline {#id} syntax to headings (standard markdown approach)
+ */
+function applyInlineIds(translatedContent, idMappings) {
+    // Parse the translated content
+    let processedAst;
+    try {
+        const parseProcessor = unified()
+            .use(remarkParse)
+            .use(remarkFrontmatter, ['yaml', 'toml'])
+            .use(remarkMdx);
+        const ast = parseProcessor.parse(translatedContent);
+        processedAst = parseProcessor.runSync(ast);
+    }
+    catch (error) {
+        console.warn(`Failed to parse translated MDX content: ${error instanceof Error ? error.message : String(error)}`);
+        return translatedContent;
+    }
+    // Apply IDs to headings based on position
+    let headingIndex = 0;
+    visit(processedAst, 'heading', (heading) => {
+        const id = idMappings.get(headingIndex);
+        if (id) {
+            // Skip if heading already has explicit ID
+            if (hasExplicitId(heading, processedAst)) {
+                headingIndex++;
+                return;
+            }
+            // Add the ID to the heading
+            const lastChild = heading.children[heading.children.length - 1];
+            if (lastChild?.type === 'text') {
+                lastChild.value += ` \\{#${id}\\}`;
+            }
+            else {
+                // If last child is not text, add a new text node
+                heading.children.push({
+                    type: 'text',
+                    value: ` \\{#${id}\\}`,
+                });
+            }
+        }
+        headingIndex++;
+    });
+    // Convert the modified AST back to MDX string
+    try {
+        const stringifyProcessor = unified()
+            .use(remarkFrontmatter, ['yaml', 'toml'])
+            .use(remarkMdx)
+            .use(escapeHtmlInTextNodes)
+            .use(remarkStringify, {
+            handlers: {
+                // Custom handler to prevent escaping of {#id} syntax
+                text(node) {
+                    return node.value;
+                },
+            },
+        });
+        const outTree = stringifyProcessor.runSync(processedAst);
+        let content = stringifyProcessor.stringify(outTree);
+        // Handle newline formatting to match original input
+        if (content.endsWith('\n') && !translatedContent.endsWith('\n')) {
+            content = content.slice(0, -1);
+        }
+        // Preserve leading newlines from original content
+        if (translatedContent.startsWith('\n') && !content.startsWith('\n')) {
+            content = '\n' + content;
+        }
+        return content;
+    }
+    catch (error) {
+        console.warn(`Failed to stringify translated MDX content: ${error instanceof Error ? error.message : String(error)}`);
+        return translatedContent;
+    }
+}
+/**
+ * Wraps headings in divs with IDs (Mintlify approach)
+ */
+function applyDivWrappedIds(translatedContent, translatedHeadings, idMappings) {
+    // Extract all heading lines from the translated markdown
+    const lines = translatedContent.split('\n');
+    const headingLines = [];
+    lines.forEach((line, index) => {
+        const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+        if (headingMatch) {
+            const level = headingMatch[1].length;
+            headingLines.push({ line, level, index });
+        }
+    });
+    // Use string-based approach to wrap headings in divs
+    let content = translatedContent;
+    const headingsToWrap = [];
+    // Match translated headings with their corresponding lines by position and level
+    translatedHeadings.forEach((heading, position) => {
+        const id = idMappings.get(position);
+        if (id) {
+            // Find the corresponding original line for this heading
+            const matchingLine = headingLines.find((hl) => {
+                // Extract clean text from the original line for comparison
+                const lineCleanText = hl.line.replace(/^#{1,6}\s+/, '').trim();
+                // Create a version without markdown formatting for comparison
+                const cleanLineText = lineCleanText
+                    .replace(/\*\*(.*?)\*\*/g, '$1') // Remove bold
+                    .replace(/\*(.*?)\*/g, '$1') // Remove italic
+                    .replace(/`(.*?)`/g, '$1') // Remove inline code
+                    .replace(/\[(.*?)\]\(.*?\)/g, '$1') // Remove links, keep text
+                    .trim();
+                return cleanLineText === heading.text && hl.level === heading.level;
+            });
+            if (matchingLine) {
+                headingsToWrap.push({
+                    originalLine: matchingLine.line,
+                    id,
+                });
+            }
+        }
+    });
+    if (headingsToWrap.length > 0) {
+        // Process headings from longest to shortest original line to avoid partial matches
+        const sortedHeadings = headingsToWrap.sort((a, b) => b.originalLine.length - a.originalLine.length);
+        for (const heading of sortedHeadings) {
+            // Escape the original line for use in regex
+            const escapedLine = heading.originalLine.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const headingPattern = new RegExp(`^${escapedLine}\\s*$`, 'gm');
+            content = content.replace(headingPattern, (match) => {
+                return `<div id="${heading.id}">\n  ${match.trim()}\n</div>\n`;
+            });
+        }
+    }
+    return content;
+}

package/dist/utils/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const GT_DASHBOARD_URL = "https://dash.generaltranslation.com";
+export declare const GT_CONFIG_SCHEMA_URL = "https://assets.gtx.dev/config-schema.json";

package/dist/utils/constants.js

@@ -0,0 +1,2 @@
+export const GT_DASHBOARD_URL = 'https://dash.generaltranslation.com';
+export const GT_CONFIG_SCHEMA_URL = 'https://assets.gtx.dev/config-schema.json';

package/dist/utils/credentials.d.ts

@@ -0,0 +1,12 @@
+import { Settings, SupportedFrameworks } from '../types/index.js';
+type Credentials = {
+    apiKey: string;
+    projectId: string;
+};
+export declare function retrieveCredentials(settings: Settings, keyType: 'development' | 'production'): Promise<Credentials>;
+export declare function generateCredentialsSession(url: string, keyType: 'development' | 'production'): Promise<{
+    sessionId: string;
+}>;
+export declare function areCredentialsSet(): string | undefined;
+export declare function setCredentials(credentials: Credentials, type: 'development' | 'production', framework?: SupportedFrameworks, cwd?: string): Promise<void>;
+export {};

package/dist/utils/credentials.js

@@ -0,0 +1,119 @@
+import { createSpinner, logErrorAndExit, logMessage, } from '../console/logging.js';
+import path from 'node:path';
+import fs from 'node:fs';
+import chalk from 'chalk';
+// Fetches project ID and API key by opening the dashboard in the browser
+export async function retrieveCredentials(settings, keyType) {
+    // Generate a session ID
+    const { sessionId } = await generateCredentialsSession(settings.baseUrl, keyType);
+    const urlToOpen = `${settings.dashboardUrl}/cli/wizard/${sessionId}`;
+    await import('open').then((open) => open.default(urlToOpen, {
+        wait: false,
+    }));
+    logMessage(`${chalk.dim(`If the browser window didn't open automatically, please open the following link:`)}\n\n${chalk.cyan(urlToOpen)}`);
+    const spinner = createSpinner('dots');
+    spinner.start('Waiting for response from dashboard...');
+    const credentials = await new Promise(async (resolve, reject) => {
+        const interval = setInterval(async () => {
+            // Ping the dashboard to see if the credentials are set
+            try {
+                const res = await fetch(`${settings.baseUrl}/cli/wizard/${sessionId}`, {
+                    method: 'GET',
+                });
+                if (res.status === 200) {
+                    const data = await res.json();
+                    resolve(data);
+                    clearInterval(interval);
+                    clearTimeout(timeout);
+                    fetch(`${settings.baseUrl}/cli/wizard/${sessionId}`, {
+                        method: 'DELETE',
+                    });
+                }
+            }
+            catch (err) {
+                console.error(err);
+            }
+        }, 2000);
+        // timeout after 1 hour
+        const timeout = setTimeout(() => {
+            spinner.stop('Timed out');
+            clearInterval(interval);
+            logErrorAndExit('Timed out waiting for response from dashboard');
+        }, 1000 * 60 * 60);
+    });
+    spinner.stop('Received credentials');
+    return credentials;
+}
+export async function generateCredentialsSession(url, keyType) {
+    const res = await fetch(`${url}/cli/wizard/session`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            keyType,
+        }),
+    });
+    if (!res.ok) {
+        logErrorAndExit('Failed to generate credentials session');
+    }
+    return await res.json();
+}
+// Checks if the credentials are set in the environment variables
+export function areCredentialsSet() {
+    return process.env.GT_PROJECT_ID && process.env.GT_API_KEY;
+}
+// Sets the credentials in .env.local file
+export async function setCredentials(credentials, type, framework, cwd = process.cwd()) {
+    const envFile = path.join(cwd, '.env.local');
+    let envContent = '';
+    // Check if .env.local exists, create it if it doesn't
+    if (!fs.existsSync(envFile)) {
+        // File doesn't exist, create it
+        await fs.promises.writeFile(envFile, '', 'utf8');
+        // Add .env.local to .gitignore if it exists
+        const gitignoreFile = path.join(cwd, '.gitignore');
+        if (fs.existsSync(gitignoreFile)) {
+            const gitignoreContent = await fs.promises.readFile(gitignoreFile, 'utf8');
+            if (!gitignoreContent.includes('.env.local')) {
+                await fs.promises.appendFile(gitignoreFile, '\n.env.local\n', 'utf8');
+            }
+        }
+        else {
+            // Create .gitignore file with .env.local
+            await fs.promises.writeFile(gitignoreFile, '.env.local\n', 'utf8');
+        }
+    }
+    else {
+        // Read existing content
+        envContent = await fs.promises.readFile(envFile, 'utf8');
+    }
+    // Always append the credentials to the file
+    let prefix = '';
+    if (framework === 'next-pages') {
+        prefix = 'NEXT_PUBLIC_';
+    }
+    else if (framework === 'vite') {
+        prefix = 'VITE_';
+    }
+    else if (framework === 'gatsby') {
+        prefix = 'GATSBY_';
+    }
+    else if (framework === 'react') {
+        prefix = 'REACT_APP_';
+    }
+    else if (framework === 'redwood') {
+        prefix = 'REDWOOD_ENV_';
+    }
+    envContent += `\n${prefix}GT_PROJECT_ID=${credentials.projectId}\n`;
+    if (type === 'development') {
+        envContent += `${prefix || ''}GT_DEV_API_KEY=${credentials.apiKey}\n`;
+    }
+    else {
+        envContent += `GT_API_KEY=${credentials.apiKey}\n`;
+    }
+    // Ensure we don't have excessive newlines
+    envContent = envContent.replace(/\n{3,}/g, '\n\n').trim() + '\n';
+    // Write the updated content back to the file
+    await fs.promises.writeFile(envFile, envContent, 'utf8');
+}

package/dist/utils/flattenJsonFiles.d.ts

@@ -0,0 +1,2 @@
+import { Settings } from '../types/index.js';
+export default function flattenJsonFiles(settings: Settings): Promise<void>;

package/dist/utils/flattenJsonFiles.js

@@ -0,0 +1,36 @@
+import { createFileMapping } from '../formats/files/fileMapping.js';
+import fs from 'node:fs';
+export default async function flattenJsonFiles(settings) {
+    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);
+    await Promise.all(Object.values(fileMapping).map(async (filesMap) => {
+        const targetFiles = Object.values(filesMap).filter((path) => path.endsWith('.json'));
+        await Promise.all(targetFiles.map(async (file) => {
+            // Read each json file
+            const json = JSON.parse(fs.readFileSync(file, 'utf8'));
+            // Flatten the json
+            const flattenedJson = flattenJson(json);
+            // Write the flattened json to the target file
+            await fs.promises.writeFile(file, JSON.stringify(flattenedJson, null, 2));
+            return flattenedJson;
+        }));
+    }));
+}
+function flattenJson(json, prefix = '') {
+    const result = {};
+    for (const [key, value] of Object.entries(json)) {
+        const newKey = prefix ? `${prefix}.${key}` : key;
+        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+            Object.assign(result, flattenJson(value, newKey));
+        }
+        else {
+            result[newKey] = value;
+        }
+    }
+    return result;
+}

package/dist/utils/gt.d.ts

@@ -0,0 +1,2 @@
+import { GT } from 'generaltranslation';
+export declare const gt: GT;

package/dist/utils/gt.js

@@ -0,0 +1,2 @@
+import { GT } from 'generaltranslation';
+export const gt = new GT();

package/dist/utils/hash.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hashes a string using SHA-256 algorithm.
+ * @param {string} string - The string to be hashed.
+ * @returns {string} The hashed string.
+ */
+export declare function hashStringSync(string: string): string;

package/dist/utils/hash.js

@@ -0,0 +1,11 @@
+import crypto from 'crypto';
+/**
+ * Hashes a string using SHA-256 algorithm.
+ * @param {string} string - The string to be hashed.
+ * @returns {string} The hashed string.
+ */
+export function hashStringSync(string) {
+    const hash = crypto.createHash('sha256');
+    hash.update(string);
+    return hash.digest('hex');
+}

package/dist/utils/headers.d.ts

@@ -0,0 +1 @@
+export declare function getAuthHeaders(projectId: string, apiKey: string): Record<string, string>;

package/dist/utils/headers.js

@@ -0,0 +1,14 @@
+export function getAuthHeaders(projectId, apiKey) {
+    const authHeaders = {
+        'x-gt-project-id': projectId,
+    };
+    if (apiKey) {
+        if (apiKey.startsWith('gtx-internal-')) {
+            authHeaders['x-gt-internal-api-key'] = apiKey;
+        }
+        else {
+            authHeaders['x-gt-api-key'] = apiKey;
+        }
+    }
+    return authHeaders;
+}

package/dist/utils/installPackage.d.ts

@@ -0,0 +1,3 @@
+import { PackageManager } from './packageManager.js';
+export declare function installPackage(packageName: string, packageManager: PackageManager, asDevDependency?: boolean, cwd?: string): Promise<void>;
+export declare function installPackageGlobal(packageName: string, version?: string): Promise<void>;

package/dist/utils/installPackage.js

@@ -0,0 +1,77 @@
+import chalk from 'chalk';
+import { spawn } from 'child_process';
+import { logError, logInfo } from '../console/logging.js';
+export async function installPackage(packageName, packageManager, asDevDependency, cwd = process.cwd()) {
+    return new Promise((resolve, reject) => {
+        const command = packageManager.name;
+        const args = [packageManager.installCommand, packageName];
+        if (asDevDependency) {
+            args.push(packageManager.devDependencyFlag);
+        }
+        const childProcess = spawn(command, args, {
+            stdio: ['pipe', 'ignore', 'pipe'],
+            cwd,
+        });
+        let errorOutput = '';
+        if (childProcess.stderr) {
+            childProcess.stderr.on('data', (data) => {
+                errorOutput += data.toString();
+            });
+        }
+        childProcess.on('error', (error) => {
+            logError(chalk.red(`Installation error: ${error.message}`));
+            logInfo(`Please manually install ${packageName} with: ${packageManager.name} ${packageManager.installCommand} ${packageName}`);
+            reject(error);
+        });
+        childProcess.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                logError(chalk.red(`Installation failed with exit code ${code}`));
+                if (errorOutput) {
+                    logError(chalk.red(`Error details: ${errorOutput}`));
+                }
+                logInfo(`Please manually install ${packageName} with: ${packageManager.name} ${packageManager.installCommand} ${packageName}`);
+                reject(new Error(`Process exited with code ${code}`));
+            }
+        });
+    });
+}
+export async function installPackageGlobal(packageName, version) {
+    return new Promise((resolve, reject) => {
+        const command = 'npm';
+        const args = [
+            'install',
+            '-g',
+            version ? `${packageName}@${version}` : packageName,
+        ];
+        const childProcess = spawn(command, args, {
+            stdio: ['pipe', 'ignore', 'pipe'],
+        });
+        let errorOutput = '';
+        if (childProcess.stderr) {
+            childProcess.stderr.on('data', (data) => {
+                errorOutput += data.toString();
+            });
+        }
+        childProcess.on('error', (error) => {
+            logError(chalk.red(`Installation error: ${error.message}`));
+            logInfo(`Please manually install ${packageName} with: npm install -g ${packageName}`);
+            reject(error);
+        });
+        childProcess.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                logError(chalk.red(`Installation failed with exit code ${code}`));
+                if (errorOutput) {
+                    logError(chalk.red(`Error details: ${errorOutput}`));
+                }
+                logInfo(`Please manually install ${packageName} with: npm install -g ${packageName}`);
+                reject(new Error(`Process exited with code ${code}`));
+            }
+        });
+    });
+}

package/dist/utils/localizeStaticImports.d.ts

@@ -0,0 +1,15 @@
+import { Settings } from '../types/index.js';
+/**
+ * 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 function localizeStaticImports(settings: Settings): Promise<void>;