gtx-cli 2.6.29 → 2.6.30-alpha.0

package/dist/utils/sharedStaticAssets.d.ts

@@ -1,9 +0,0 @@
-import type { Settings } from '../types/index.js';
-export declare function mirrorAssetsToLocales(settings: Settings): Promise<void>;
-/**
- * If you specify in config you have blob patterns pointing to assets (jpg, png, etc.)
- * Moves static assets into a specified directory and goes thru src files and updates refrence to static assets
- * @param settings
- * @returns
- */
-export default function processSharedStaticAssets(settings: Settings): Promise<void>;

package/dist/utils/sharedStaticAssets.js

@@ -1,384 +0,0 @@
-import path from 'node:path';
-import fs from 'node:fs';
-import fg from 'fast-glob';
-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, normalizeCJKCharacters } from 'gt-remark';
-import { createFileMapping } from '../formats/files/fileMapping.js';
-import { TEMPLATE_FILE_NAME } from './constants.js';
-function derivePublicPath(outDir, provided) {
-    if (provided)
-        return provided;
-    const norm = outDir.replace(/\\/g, '/');
-    if (norm.startsWith('public/'))
-        return '/' + norm.slice('public/'.length);
-    if (norm.startsWith('static/'))
-        return '/' + norm.slice('static/'.length);
-    if (norm.startsWith('/'))
-        return norm; // already absolute URL path
-    return '/' + path.basename(norm);
-}
-function toArray(val) {
-    if (!val)
-        return [];
-    return Array.isArray(val) ? val : [val];
-}
-async function ensureDir(dir) {
-    await fs.promises.mkdir(dir, { recursive: true });
-}
-async function moveFile(src, dest) {
-    if (src === dest)
-        return;
-    try {
-        await ensureDir(path.dirname(dest));
-        await fs.promises.rename(src, dest);
-    }
-    catch (err) {
-        // Fallback to copy+unlink for cross-device or existing files
-        if (err &&
-            (err.code === 'EXDEV' ||
-                err.code === 'EEXIST' ||
-                err.code === 'ENOTEMPTY')) {
-            const data = await fs.promises.readFile(src);
-            await ensureDir(path.dirname(dest));
-            await fs.promises.writeFile(dest, data);
-            try {
-                await fs.promises.unlink(src);
-            }
-            catch { }
-        }
-        else if (err && err.code === 'ENOENT') {
-            // already moved or missing; ignore
-            return;
-        }
-        else {
-            throw err;
-        }
-    }
-}
-async function pathExists(p) {
-    try {
-        await fs.promises.stat(p);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function isDirEmpty(dir) {
-    try {
-        const entries = await fs.promises.readdir(dir);
-        return entries.length === 0;
-    }
-    catch {
-        return false;
-    }
-}
-async function removeEmptyDirsUpwards(startDir, stopDir) {
-    let current = path.resolve(startDir);
-    const stop = path.resolve(stopDir);
-    while (current.startsWith(stop)) {
-        if (current === stop)
-            break;
-        const exists = await pathExists(current);
-        if (!exists)
-            break;
-        const empty = await isDirEmpty(current);
-        if (!empty)
-            break;
-        try {
-            await fs.promises.rmdir(current);
-        }
-        catch {
-            break;
-        }
-        const parent = path.dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-}
-function stripQueryAndHash(url) {
-    const match = url.match(/^[^?#]+/);
-    const base = match ? match[0] : url;
-    const suffix = url.slice(base.length);
-    return { base, suffix };
-}
-function rewriteMdxContent(content, filePath, pathMap) {
-    let changed = false;
-    let ast;
-    try {
-        const processor = unified()
-            .use(remarkParse)
-            .use(remarkFrontmatter, ['yaml', 'toml'])
-            .use(remarkMdx);
-        ast = processor.runSync(processor.parse(content));
-    }
-    catch (e) {
-        return { content, changed: false };
-    }
-    const fileDir = path.dirname(filePath);
-    // Helper to resolve and possibly rewrite a URL
-    const maybeRewrite = (url) => {
-        if (!url ||
-            /^(https?:)?\/\//i.test(url) ||
-            url.startsWith('data:') ||
-            url.startsWith('#') ||
-            url.startsWith('mailto:') ||
-            url.startsWith('tel:')) {
-            return null;
-        }
-        const { base, suffix } = stripQueryAndHash(url);
-        // Only handle relative paths
-        if (base.startsWith('/'))
-            return null;
-        const abs = path.resolve(fileDir, base);
-        const normAbs = path.normalize(abs);
-        const mapped = pathMap.get(normAbs);
-        if (mapped) {
-            changed = true;
-            return mapped + suffix;
-        }
-        return null;
-    };
-    visit(ast, (node) => {
-        // Markdown image: ![alt](url)
-        if (node.type === 'image' && typeof node.url === 'string') {
-            const newUrl = maybeRewrite(node.url);
-            if (newUrl)
-                node.url = newUrl;
-            return;
-        }
-        // Markdown link: [text](url) — useful for PDFs and other downloadable assets
-        if (node.type === 'link' && typeof node.url === 'string') {
-            const newUrl = maybeRewrite(node.url);
-            if (newUrl)
-                node.url = newUrl;
-            return;
-        }
-        // MDX <img src="..." />
-        if ((node.type === 'mdxJsxFlowElement' ||
-            node.type === 'mdxJsxTextElement') &&
-            Array.isArray(node.attributes)) {
-            for (const attr of node.attributes) {
-                if (attr &&
-                    attr.type === 'mdxJsxAttribute' &&
-                    (attr.name === 'src' || attr.name === 'href') &&
-                    typeof attr.value === 'string') {
-                    const newUrl = maybeRewrite(attr.value);
-                    if (newUrl)
-                        attr.value = newUrl;
-                }
-            }
-        }
-    });
-    try {
-        const s = unified()
-            .use(remarkFrontmatter, ['yaml', 'toml'])
-            .use(remarkMdx)
-            .use(normalizeCJKCharacters)
-            .use(escapeHtmlInTextNodes)
-            .use(remarkStringify, {
-            handlers: {
-                text(node) {
-                    return node.value;
-                },
-            },
-        });
-        const outTree = s.runSync(ast);
-        let out = s.stringify(outTree);
-        // Preserve trailing/leading newlines similar to localizeStaticUrls
-        if (out.endsWith('\n') && !content.endsWith('\n'))
-            out = out.slice(0, -1);
-        if (content.startsWith('\n') && !out.startsWith('\n'))
-            out = '\n' + out;
-        return { content: out, changed };
-    }
-    catch (e) {
-        return { content, changed: false };
-    }
-}
-function resolveAssetPaths(include, cwd) {
-    const assetPaths = new Set();
-    for (let pattern of include) {
-        if (pattern.startsWith('/'))
-            pattern = pattern.slice(1);
-        const matches = fg.sync(path.resolve(cwd, pattern), { absolute: true });
-        for (const m of matches)
-            assetPaths.add(path.normalize(m));
-    }
-    return assetPaths;
-}
-export async function mirrorAssetsToLocales(settings) {
-    const cfg = settings.sharedStaticAssets;
-    if (!cfg?.mirrorToLocales)
-        return;
-    if (!settings.files)
-        return;
-    const cwd = process.cwd();
-    const include = toArray(cfg.include);
-    if (include.length === 0)
-        return;
-    const assetPaths = resolveAssetPaths(include, cwd);
-    if (assetPaths.size === 0)
-        return;
-    const { resolvedPaths, placeholderPaths, transformPaths } = settings.files;
-    const targetLocales = settings.locales.filter((l) => l !== settings.defaultLocale);
-    if (targetLocales.length === 0)
-        return;
-    const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, targetLocales, settings.defaultLocale);
-    for (const locale of targetLocales) {
-        const filesMap = fileMapping[locale];
-        if (!filesMap)
-            continue;
-        // Extract unique (sourceDir, targetDir) pairs from the file mapping
-        const dirPairs = new Map();
-        for (const [sourcePath, targetPath] of Object.entries(filesMap)) {
-            if (sourcePath === TEMPLATE_FILE_NAME)
-                continue;
-            const sourceDir = path.dirname(path.resolve(cwd, sourcePath));
-            const targetDir = path.dirname(path.resolve(cwd, targetPath));
-            if (sourceDir !== targetDir) {
-                dirPairs.set(sourceDir, targetDir);
-            }
-        }
-        if (dirPairs.size === 0)
-            continue;
-        // Derive ancestor directory pairs by walking up from each known pair.
-        // e.g. if docs/guide → ja/docs/guide, infer docs → ja/docs.
-        // Stop at cwd or when an existing pair conflicts.
-        const ancestorPairs = new Map();
-        for (const [sourceDir, targetDir] of dirPairs) {
-            let s = path.dirname(sourceDir);
-            let t = path.dirname(targetDir);
-            while (s.startsWith(cwd) && s !== cwd) {
-                const existing = dirPairs.get(s) ?? ancestorPairs.get(s);
-                if (existing !== undefined) {
-                    if (existing !== t)
-                        break; // conflict — different transforms
-                }
-                else {
-                    ancestorPairs.set(s, t);
-                }
-                s = path.dirname(s);
-                t = path.dirname(t);
-            }
-        }
-        for (const [s, t] of ancestorPairs) {
-            dirPairs.set(s, t);
-        }
-        // Sort source dirs by length descending so longest prefix matches first
-        const sortedPairs = [...dirPairs.entries()].sort((a, b) => b[0].length - a[0].length);
-        for (const assetAbs of assetPaths) {
-            // Find the directory pair whose sourceDir is the longest prefix of the asset
-            let bestSource;
-            let bestTarget;
-            for (const [sourceDir, targetDir] of sortedPairs) {
-                if (assetAbs.startsWith(sourceDir + path.sep) ||
-                    assetAbs.startsWith(sourceDir + '/')) {
-                    bestSource = sourceDir;
-                    bestTarget = targetDir;
-                    break;
-                }
-            }
-            if (!bestSource || !bestTarget)
-                continue;
-            const relFromSource = path.relative(bestSource, assetAbs);
-            const targetAsset = path.resolve(bestTarget, relFromSource);
-            // Skip if target already exists with same size
-            try {
-                const [srcStat, dstStat] = await Promise.all([
-                    fs.promises.stat(assetAbs),
-                    fs.promises.stat(targetAsset),
-                ]);
-                if (dstStat.isFile() && srcStat.size === dstStat.size)
-                    continue;
-            }
-            catch {
-                // target doesn't exist, proceed with copy
-            }
-            await ensureDir(path.dirname(targetAsset));
-            await fs.promises.copyFile(assetAbs, targetAsset);
-        }
-    }
-}
-/**
- * If you specify in config you have blob patterns pointing to assets (jpg, png, etc.)
- * Moves static assets into a specified directory and goes thru src files and updates refrence to static assets
- * @param settings
- * @returns
- */
-export default async function processSharedStaticAssets(settings) {
-    const cfg = settings.sharedStaticAssets;
-    if (!cfg)
-        return;
-    // mirrorToLocales is handled separately after translations are downloaded
-    if (cfg.mirrorToLocales)
-        return;
-    const cwd = process.cwd();
-    const include = toArray(cfg.include);
-    if (include.length === 0)
-        return;
-    // Resolve assets
-    const assetPaths = resolveAssetPaths(include, cwd);
-    if (assetPaths.size === 0)
-        return;
-    if (!cfg.outDir)
-        return;
-    const outDirInput = cfg.outDir.startsWith('/')
-        ? cfg.outDir.slice(1)
-        : cfg.outDir;
-    const outDirAbs = path.resolve(cwd, outDirInput);
-    const publicPath = derivePublicPath(outDirInput, cfg.publicPath);
-    // Map original absolute path -> public URL
-    const originalToPublic = new Map();
-    for (const abs of assetPaths) {
-        const relFromRoot = path.relative(cwd, abs).replace(/\\/g, '/');
-        const publicUrl = (publicPath.endsWith('/') ? publicPath.slice(0, -1) : publicPath) +
-            '/' +
-            relFromRoot;
-        originalToPublic.set(path.normalize(abs), publicUrl);
-    }
-    // Move assets to outDir, preserving relative structure
-    for (const abs of assetPaths) {
-        const relFromRoot = path.relative(cwd, abs);
-        const destAbs = path.resolve(outDirAbs, relFromRoot);
-        // Skip if already in destination
-        if (path.normalize(abs) === path.normalize(destAbs))
-            continue;
-        // If destination exists, assume already moved
-        try {
-            const st = await fs.promises.stat(destAbs).catch(() => null);
-            if (st && st.isFile()) {
-                // Remove source if it still exists
-                await fs.promises.unlink(abs).catch(() => { });
-                await removeEmptyDirsUpwards(path.dirname(abs), cwd);
-                continue;
-            }
-        }
-        catch { }
-        await moveFile(abs, destAbs);
-        await removeEmptyDirsUpwards(path.dirname(abs), cwd);
-    }
-    // Rewrite references in default-locale files we send for translation
-    const resolved = settings.files?.resolvedPaths || {};
-    const mdFiles = [...(resolved.mdx || []), ...(resolved.md || [])];
-    await Promise.all(mdFiles.map(async (filePath) => {
-        // only rewrite existing files
-        const exists = await fs.promises
-            .stat(filePath)
-            .then(() => true)
-            .catch(() => false);
-        if (!exists)
-            return;
-        const orig = await fs.promises.readFile(filePath, 'utf8');
-        const { content: out, changed } = rewriteMdxContent(orig, filePath, originalToPublic);
-        if (changed) {
-            await fs.promises.writeFile(filePath, out, 'utf8');
-        }
-    }));
-}

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 };
-    }
-}

package/dist/workflows/download.d.ts

@@ -1,32 +0,0 @@
-import { Settings } from '../types/index.js';
-import { EnqueueFilesResult } from 'generaltranslation/types';
-import { BranchData } from '../types/branch.js';
-export type FileTranslationData = {
-    [fileId: string]: {
-        versionId: string;
-        fileName: string;
-    };
-};
-/**
- * Checks the status of translations and downloads them using a workflow pattern
- * @param fileVersionData - Mapping of file IDs to their version and name information
- * @param jobData - Optional job data from enqueue operation
- * @param locales - The locales to wait for
- * @param timeoutDuration - The timeout duration for the wait in seconds
- * @param resolveOutputPath - Function to resolve the output path for a given source path and locale
- * @param options - Settings configuration
- * @param forceRetranslation - Whether to force retranslation
- * @param forceDownload - Whether to force download even if file exists
- * @returns True if all translations are downloaded successfully, false otherwise
- */
-export declare function runDownloadWorkflow({ fileVersionData, jobData, branchData, locales, timeoutDuration, resolveOutputPath, options, forceRetranslation, forceDownload, }: {
-    fileVersionData: FileTranslationData;
-    jobData: EnqueueFilesResult | undefined;
-    branchData: BranchData | undefined;
-    locales: string[];
-    timeoutDuration: number;
-    resolveOutputPath: (sourcePath: string, locale: string) => string | null;
-    options: Settings;
-    forceRetranslation?: boolean;
-    forceDownload?: boolean;
-}): Promise<boolean>;

package/dist/workflows/download.js

@@ -1,127 +0,0 @@
-import path from 'node:path';
-import { gt } from '../utils/gt.js';
-import { clearLocaleDirs } from '../fs/clearLocaleDirs.js';
-import { PollTranslationJobsStep, } from './steps/PollJobsStep.js';
-import { DownloadTranslationsStep } from './steps/DownloadStep.js';
-import { logErrorAndExit } from '../console/logging.js';
-import { logger } from '../console/logger.js';
-import { recordWarning } from '../state/translateWarnings.js';
-import { BranchStep } from './steps/BranchStep.js';
-import chalk from 'chalk';
-/**
- * Checks the status of translations and downloads them using a workflow pattern
- * @param fileVersionData - Mapping of file IDs to their version and name information
- * @param jobData - Optional job data from enqueue operation
- * @param locales - The locales to wait for
- * @param timeoutDuration - The timeout duration for the wait in seconds
- * @param resolveOutputPath - Function to resolve the output path for a given source path and locale
- * @param options - Settings configuration
- * @param forceRetranslation - Whether to force retranslation
- * @param forceDownload - Whether to force download even if file exists
- * @returns True if all translations are downloaded successfully, false otherwise
- */
-export async function runDownloadWorkflow({ fileVersionData, jobData, branchData, locales, timeoutDuration, resolveOutputPath, options, forceRetranslation, forceDownload, }) {
-    if (!branchData) {
-        // Run the branch step
-        const branchStep = new BranchStep(gt, options);
-        const branchResult = await branchStep.run();
-        await branchStep.wait();
-        if (!branchResult) {
-            return logErrorAndExit('Failed to resolve git branch information.');
-        }
-        branchData = branchResult;
-    }
-    // Prepare the query data
-    const fileQueryData = prepareFileQueryData(fileVersionData, locales, branchData);
-    // Clear translated files before any downloads (if enabled)
-    if (options.options?.experimentalClearLocaleDirs === true &&
-        fileQueryData.length > 0) {
-        const translatedFiles = new Set(fileQueryData
-            .map((file) => {
-            const outputPath = resolveOutputPath(file.fileName, file.locale);
-            // Only clear if the output path is different from the source (i.e., there's a transform)
-            return outputPath !== null && outputPath !== file.fileName
-                ? outputPath
-                : null;
-        })
-            .filter((path) => path !== null));
-        // Derive cwd from config path
-        const cwd = path.dirname(options.config);
-        await clearLocaleDirs(translatedFiles, locales, options.options?.clearLocaleDirsExclude, cwd);
-    }
-    // Initialize download status
-    const fileTracker = {
-        completed: new Map(),
-        inProgress: new Map(),
-        failed: new Map(),
-        skipped: new Map(),
-    };
-    // Step 1: Poll translation jobs if jobData exists
-    let pollTimedOut = false;
-    if (jobData) {
-        const pollStep = new PollTranslationJobsStep(gt);
-        const pollResult = await pollStep.run({
-            fileTracker,
-            fileQueryData,
-            jobData,
-            timeoutDuration,
-            forceRetranslation,
-        });
-        await pollStep.wait();
-        if (pollResult.fileTracker.failed.size > 0) {
-            logger.error(`${chalk.red(`${pollResult.fileTracker.failed.size} file(s) failed to translate:`)}\n${Array.from(pollResult.fileTracker.failed.entries())
-                .map(([, value]) => `- ${value.fileName}`)
-                .join('\n')}`);
-            for (const [, value] of pollResult.fileTracker.failed) {
-                recordWarning('failed_translation', value.fileName, `Failed to translate for locale ${value.locale}`);
-            }
-        }
-        // Even if polling timed out, still download whatever completed successfully
-        if (!pollResult.success) {
-            pollTimedOut = true;
-            if (pollResult.fileTracker.completed.size > 0) {
-                logger.warn(chalk.yellow(`Timed out, but ${pollResult.fileTracker.completed.size} translation(s) completed successfully. Downloading completed files...`));
-            }
-            else {
-                return false;
-            }
-        }
-    }
-    else {
-        for (const file of fileQueryData) {
-            // Staging - assume all files are completed
-            fileTracker.completed.set(`${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`, file);
-        }
-    }
-    // Step 2: Download translations
-    const downloadStep = new DownloadTranslationsStep(gt, options);
-    const downloadResult = await downloadStep.run({
-        fileTracker,
-        resolveOutputPath,
-        forceDownload,
-    });
-    await downloadStep.wait();
-    // If polling timed out, report failure even though we downloaded what we could
-    if (pollTimedOut) {
-        return false;
-    }
-    return downloadResult;
-}
-/**
- * Prepares the file query data from input data and locales
- */
-function prepareFileQueryData(fileVersionData, locales, branchData) {
-    const fileQueryData = [];
-    for (const fileId in fileVersionData) {
-        for (const locale of locales) {
-            fileQueryData.push({
-                versionId: fileVersionData[fileId].versionId,
-                fileName: fileVersionData[fileId].fileName,
-                fileId,
-                locale,
-                branchId: branchData.currentBranch.id,
-            });
-        }
-    }
-    return fileQueryData;
-}

package/dist/workflows/enqueue.d.ts

@@ -1,17 +0,0 @@
-import { Settings, TranslateFlags } from '../types/index.js';
-import { EnqueueFilesResult, FileToUpload } from 'generaltranslation/types';
-/**
- * Enqueues translations for a given set of files
- *  - Only enqueues uploaded files
- *  - Don't have to worry about double enqueuing files because dedupe on API side
- *
- * @param {FileTranslationData} fileVersionData - The file version data
- * @param {TranslateFlags} options - The options for the enqueue operation
- * @param {Settings} settings - The settings for the enqueue operation
- * @returns {Promise<EnqueueFilesResult>} The enqueue result
- */
-export declare function runEnqueueWorkflow({ files, options, settings, }: {
-    files: FileToUpload[];
-    options: TranslateFlags;
-    settings: Settings;
-}): Promise<EnqueueFilesResult>;

package/dist/workflows/enqueue.js

@@ -1,59 +0,0 @@
-import { logCollectedFiles, logErrorAndExit } from '../console/logging.js';
-import { gt } from '../utils/gt.js';
-import { EnqueueStep } from './steps/EnqueueStep.js';
-import { BranchStep } from './steps/BranchStep.js';
-import { logger } from '../console/logger.js';
-/**
- * Enqueues translations for a given set of files
- *  - Only enqueues uploaded files
- *  - Don't have to worry about double enqueuing files because dedupe on API side
- *
- * @param {FileTranslationData} fileVersionData - The file version data
- * @param {TranslateFlags} options - The options for the enqueue operation
- * @param {Settings} settings - The settings for the enqueue operation
- * @returns {Promise<EnqueueFilesResult>} The enqueue result
- */
-export async function runEnqueueWorkflow({ files, options, settings, }) {
-    try {
-        // Log files to be enqueued
-        logCollectedFiles(files);
-        logger.debug('Files: ' + JSON.stringify(files, null, 2));
-        // Create workflow with steps
-        const branchStep = new BranchStep(gt, settings);
-        // const queryFileDataStep = new QueryFileDataStep(gt);
-        const enqueueStep = new EnqueueStep(gt, settings, options.force);
-        // (1) run the branch step
-        const branchData = await branchStep.run();
-        await branchStep.wait();
-        if (!branchData) {
-            return logErrorAndExit('Failed to resolve git branch information.');
-        }
-        logger.debug('Branch data: ' + JSON.stringify(branchData, null, 2));
-        // (2) Enqueue the files
-        const enqueueResult = await enqueueStep.run(files.map((files) => ({
-            branchId: branchData.currentBranch.id,
-            ...files,
-        })));
-        await enqueueStep.wait();
-        logger.debug('Enqueue result: ' + JSON.stringify(enqueueResult, null, 2));
-        logEnqueueResult(enqueueResult, files);
-        return enqueueResult;
-    }
-    catch (error) {
-        return logErrorAndExit('Failed to enqueue translations. ' + error);
-    }
-}
-// ----- Helper functions ----- //
-/**
- * Logs the enqueue result
- * @param enqueueResult - The enqueue result
- * @returns void
- */
-function logEnqueueResult(enqueueResult, files) {
-    if (Object.keys(enqueueResult.jobData).length === 0) {
-        logger.success(`All ${files.length} files already translated. 0 files enqueued.`);
-    }
-    else {
-        logger.success(enqueueResult.message);
-    }
-}

package/dist/workflows/setupProject.d.ts

@@ -1,13 +0,0 @@
-import { Settings, TranslateFlags } from '../types/index.js';
-import { FileToUpload } from 'generaltranslation/types';
-import { BranchData } from '../types/branch.js';
-/**
- * Sets up a project by uploading files running the setup step
- * @param files - Array of file objects to upload
- * @param options - The options for the API call
- * @param settings - Settings configuration
- * @returns The branch data
- */
-export declare function runSetupProjectWorkflow(files: FileToUpload[], options: TranslateFlags, settings: Settings): Promise<{
-    branchData: BranchData;
-}>;