gtx-cli 2.6.29 → 2.6.30-alpha.0

package/dist/utils/addExplicitAnchorIds.js

@@ -1,416 +0,0 @@
-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 { logger } from '../console/logger.js';
-import { escapeHtmlInTextNodes, normalizeCJKCharacters } from 'gt-remark';
-import { decode } from 'html-entities';
-/**
- * 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;
-}
-/**
- * Simple line-by-line heading extractor that skips fenced code blocks.
- * Used as a fallback when MDX parsing fails.
- */
-function extractHeadingsWithFallback(mdxContent) {
-    const headings = [];
-    const lines = mdxContent.split('\n');
-    let position = 0;
-    let inFence = false;
-    let fenceChar = null;
-    for (const line of lines) {
-        const fenceMatch = line.match(/^(\s*)(`{3,}|~{3,})/);
-        if (fenceMatch) {
-            const fenceString = fenceMatch[2];
-            if (!inFence) {
-                inFence = true;
-                fenceChar = fenceString;
-            }
-            else if (fenceChar &&
-                fenceString[0] === fenceChar[0] &&
-                fenceString.length >= fenceChar.length) {
-                inFence = false;
-                fenceChar = null;
-            }
-            continue;
-        }
-        if (inFence) {
-            continue;
-        }
-        const headingMatch = line.match(/^(#{1,6})\s+(.*)$/);
-        if (!headingMatch) {
-            continue;
-        }
-        const hashes = headingMatch[1];
-        const rawText = headingMatch[2];
-        const { cleanedText, explicitId } = parseHeadingContent(rawText);
-        if (cleanedText || explicitId) {
-            headings.push({
-                text: cleanedText,
-                level: hashes.length,
-                slug: explicitId ?? generateSlug(cleanedText),
-                position: position++,
-            });
-        }
-    }
-    return headings;
-}
-function parseHeadingContent(text) {
-    // Support both {#id} and escaped \{#id\} forms
-    const anchorMatch = text.match(/(\\\{#([^}]+)\\\}|\{#([^}]+)\})\s*$/);
-    if (!anchorMatch) {
-        return { cleanedText: text };
-    }
-    const explicitId = anchorMatch[2] || anchorMatch[3];
-    const cleanedText = text.replace(anchorMatch[0], '').trimEnd();
-    return { cleanedText, explicitId };
-}
-/**
- * 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 /(\{#[^}]+\}|\\\{#[^}]+\\\}|\[[^\]]+\])\s*$/.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 {
-        // Fallback: line-by-line extraction skipping fenced code blocks
-        return extractHeadingsWithFallback(mdxContent);
-    }
-    let position = 0;
-    visit(processedAst, 'heading', (heading) => {
-        const headingText = extractHeadingText(heading);
-        const { cleanedText, explicitId } = parseHeadingContent(headingText);
-        if (cleanedText || explicitId) {
-            const slug = explicitId ?? generateSlug(cleanedText);
-            headings.push({
-                text: cleanedText,
-                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, fileTypeHint) {
-    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';
-        logger.warn(`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: [],
-        };
-    }
-    const translatedIsMdx = translatedPath
-        ? translatedPath.toLowerCase().endsWith('.mdx')
-        : true; // default to mdx-style escaping when unknown
-    const shouldEscapeAnchors = fileTypeHint === 'mdx'
-        ? true
-        : fileTypeHint === 'md'
-            ? false
-            : translatedIsMdx;
-    // Apply IDs to translated content
-    let content;
-    if (useDivWrapping) {
-        content = applyDivWrappedIds(translatedContent, translatedHeadings, idMappings);
-    }
-    else {
-        content = applyInlineIds(translatedContent, idMappings, shouldEscapeAnchors);
-    }
-    return {
-        content,
-        hasChanges: content !== translatedContent,
-        addedIds,
-    };
-}
-/**
- * Adds inline {#id} syntax to headings (standard markdown approach)
- */
-function applyInlineIds(translatedContent, idMappings, escapeAnchors) {
-    const escapeInlineAnchors = (content) => {
-        if (!escapeAnchors)
-            return content;
-        return content.replace(/\{#([A-Za-z0-9-_]+)\}/g, (match, id, offset, str) => {
-            if (offset > 0 && str[offset - 1] === '\\') {
-                return match;
-            }
-            return `\\{#${id}\\}`;
-        });
-    };
-    // 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 {
-        return applyInlineIdsStringFallback(translatedContent, idMappings, escapeAnchors);
-    }
-    // Apply IDs to headings based on position
-    let headingIndex = 0;
-    let actuallyModifiedContent = false;
-    visit(processedAst, 'heading', (heading) => {
-        const id = idMappings.get(headingIndex);
-        if (id) {
-            // Skip if heading already has explicit ID
-            if (hasExplicitId(heading, processedAst)) {
-                if (escapeAnchors) {
-                    // Normalize existing inline IDs to escaped form
-                    const lastChild = heading.children[heading.children.length - 1];
-                    if (lastChild?.type === 'text') {
-                        const match = lastChild.value.match(/\{#([^}]+)\}\s*$/);
-                        const alreadyEscaped = lastChild.value.match(/\\\{#[^}]+\\\}\s*$/);
-                        if (match && !alreadyEscaped) {
-                            const anchorId = match[1];
-                            const base = lastChild.value.replace(/\s*\{#[^}]+\}\s*$/, '');
-                            lastChild.value = `${base} \\{#${anchorId}\\}`;
-                            actuallyModifiedContent = true;
-                        }
-                    }
-                }
-                headingIndex++;
-                return;
-            }
-            // Add the ID to the heading
-            const lastChild = heading.children[heading.children.length - 1];
-            if (lastChild?.type === 'text') {
-                lastChild.value += escapeAnchors ? ` \\{#${id}\\}` : ` {#${id}}`;
-            }
-            else {
-                // If last child is not text, add a new text node
-                heading.children.push({
-                    type: 'text',
-                    value: escapeAnchors ? ` \\{#${id}\\}` : ` {#${id}}`,
-                });
-            }
-            actuallyModifiedContent = true;
-        }
-        headingIndex++;
-    });
-    // If we didn't modify any headings, return original content
-    if (!actuallyModifiedContent) {
-        const escaped = escapeInlineAnchors(translatedContent);
-        return escaped;
-    }
-    // Convert the modified AST back to MDX string
-    try {
-        const stringifyProcessor = unified()
-            .use(remarkFrontmatter, ['yaml', 'toml'])
-            .use(remarkMdx)
-            .use(normalizeCJKCharacters)
-            .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 {
-        return translatedContent;
-    }
-}
-/**
- * Fallback string-based inline ID application when AST parsing fails
- */
-function applyInlineIdsStringFallback(translatedContent, idMappings, escapeAnchors) {
-    let headingIndex = 0;
-    let inFence = false;
-    let fenceChar = null;
-    const processedLines = translatedContent.split('\n').map((line) => {
-        const fenceMatch = line.match(/^(\s*)(`{3,}|~{3,})/);
-        if (fenceMatch) {
-            const fenceString = fenceMatch[2];
-            if (!inFence) {
-                inFence = true;
-                fenceChar = fenceString;
-            }
-            else if (fenceChar &&
-                fenceString[0] === fenceChar[0] &&
-                fenceString.length >= fenceChar.length) {
-                inFence = false;
-                fenceChar = null;
-            }
-            return line;
-        }
-        if (inFence) {
-            return line;
-        }
-        const headingMatch = line.match(/^(#{1,6}\s+)(.*)$/);
-        if (!headingMatch) {
-            return line;
-        }
-        const prefix = headingMatch[1];
-        const text = headingMatch[2];
-        const id = idMappings.get(headingIndex++);
-        if (!id) {
-            return line;
-        }
-        const hasEscaped = /\\\{#[^}]+\\\}\s*$/.test(text);
-        const hasUnescaped = /\{#[^}]+\}\s*$/.test(text);
-        if (hasEscaped) {
-            return line;
-        }
-        if (hasUnescaped) {
-            if (!escapeAnchors) {
-                return line;
-            }
-            return `${prefix}${text.replace(/\{#([^}]+)\}\s*$/, '\\{#$1\\}')}`;
-        }
-        const suffix = escapeAnchors ? ` \\{#${id}\\}` : ` {#${id}}`;
-        return `${prefix}${text}${suffix}`;
-    });
-    return processedLines.join('\n');
-}
-/**
- * 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();
-                const normalizedLineText = decode(cleanLineText).trim();
-                const normalizedHeadingText = decode(heading.text).trim();
-                return (normalizedLineText === normalizedHeadingText &&
-                    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) {
-            // If already wrapped with this id, skip (idempotent)
-            if (content.includes(`<div id="${heading.id}">`)) {
-                continue;
-            }
-            // 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

@@ -1,5 +0,0 @@
-export declare const GT_DASHBOARD_URL = "https://dash.generaltranslation.com";
-export declare const GT_CONFIG_SCHEMA_URL = "https://assets.gtx.dev/config-schema.json";
-export declare const TEMPLATE_FILE_NAME = "__INTERNAL_GT_TEMPLATE_NAME__";
-export declare const TEMPLATE_FILE_ID: string;
-export declare const DEFAULT_GIT_REMOTE_NAME = "origin";

package/dist/utils/constants.js

@@ -1,6 +0,0 @@
-import { hashStringSync } from './hash.js';
-export const GT_DASHBOARD_URL = 'https://dash.generaltranslation.com';
-export const GT_CONFIG_SCHEMA_URL = 'https://assets.gtx.dev/config-schema.json';
-export const TEMPLATE_FILE_NAME = '__INTERNAL_GT_TEMPLATE_NAME__';
-export const TEMPLATE_FILE_ID = hashStringSync(TEMPLATE_FILE_NAME);
-export const DEFAULT_GIT_REMOTE_NAME = 'origin';

package/dist/utils/credentials.d.ts

@@ -1,12 +0,0 @@
-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

@@ -1,120 +0,0 @@
-import { logErrorAndExit } from '../console/logging.js';
-import { logger } from '../console/logger.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,
-    }));
-    logger.message(`${chalk.dim(`If the browser window didn't open automatically, please open the following link:`)}\n\n${chalk.cyan(urlToOpen)}`);
-    const spinner = logger.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

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

package/dist/utils/flattenJsonFiles.js

@@ -1,36 +0,0 @@
-import { createFileMapping } from '../formats/files/fileMapping.js';
-import fs from 'node:fs';
-export default async function flattenJsonFiles(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);
-    await Promise.all(Object.values(fileMapping).map(async (filesMap) => {
-        const targetFiles = Object.values(filesMap).filter((p) => p.endsWith('.json') && (!includeFiles || includeFiles.has(p)));
-        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/gitDiff.d.ts

@@ -1,8 +0,0 @@
-/**
- * Returns a unified diff using the system's git, comparing two paths even if not in a repo.
- * Uses `git diff --no-index` so neither path needs to be tracked by git.
- *
- * Exit codes: 0 (no changes), 1 (changes), >1 (error). We treat 0/1 as success.
- * Throws if git is unavailable or another error occurs.
- */
-export declare function getGitUnifiedDiff(oldPath: string, newPath: string): Promise<string>;

package/dist/utils/gitDiff.js

@@ -1,34 +0,0 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-const execFileAsync = promisify(execFile);
-/**
- * Returns a unified diff using the system's git, comparing two paths even if not in a repo.
- * Uses `git diff --no-index` so neither path needs to be tracked by git.
- *
- * Exit codes: 0 (no changes), 1 (changes), >1 (error). We treat 0/1 as success.
- * Throws if git is unavailable or another error occurs.
- */
-export async function getGitUnifiedDiff(oldPath, newPath) {
-    try {
-        const res = await execFileAsync('git', [
-            'diff',
-            '--no-index',
-            '--text',
-            '--unified=3',
-            '--no-color',
-            '--',
-            oldPath,
-            newPath,
-        ], {
-            windowsHide: true,
-        });
-        return res.stdout || '';
-    }
-    catch (error) {
-        // Exit code 1 means differences found; stdout contains the diff
-        if (error && error.code === 1 && typeof error.stdout === 'string') {
-            return error.stdout;
-        }
-        throw error;
-    }
-}

package/dist/utils/gt.d.ts

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

package/dist/utils/gt.js

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

package/dist/utils/hash.d.ts

@@ -1,6 +0,0 @@
-/**
- * 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

@@ -1,11 +0,0 @@
-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

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