gtx-cli 2.6.31 → 2.7.0

package/dist/utils/localizeStaticUrls.js

@@ -1,450 +0,0 @@
-import * as fs from 'fs';
-import { createFileMapping } from '../formats/files/fileMapping.js';
-import micromatch from 'micromatch';
-import { unified } from 'unified';
-import remarkParse from 'remark-parse';
-import remarkMdx from 'remark-mdx';
-import remarkFrontmatter from 'remark-frontmatter';
-import remarkStringify from 'remark-stringify';
-import { visit } from 'unist-util-visit';
-import { escapeHtmlInTextNodes, normalizeCJKCharacters } from 'gt-remark';
-const { isMatch } = micromatch;
-/**
- * Localizes static urls in content files.
- * Currently only supported for md and mdx files. (/docs/ -> /[locale]/docs/)
- * @param settings - The settings object containing the project configuration.
- * @returns void
- *
- * @TODO This is an experimental feature, and only works in very specific cases. This needs to be improved before
- * it can be enabled by default.
- *
- * Before this becomes a non-experimental feature, we need to:
- * - Support more file types
- * - Support more complex paths
- */
-export default async function localizeStaticUrls(settings, targetLocales, includeFiles) {
-    if (!settings.files ||
-        (Object.keys(settings.files.placeholderPaths).length === 1 &&
-            settings.files.placeholderPaths.gt)) {
-        return;
-    }
-    const { resolvedPaths: sourceFiles } = settings.files;
-    // Use filtered locales if provided, otherwise use all locales
-    const locales = targetLocales || settings.locales;
-    const fileMapping = createFileMapping(sourceFiles, settings.files.placeholderPaths, settings.files.transformPaths, settings.locales, // Always use all locales for mapping, filter later
-    settings.defaultLocale);
-    // Process all file types at once with a single call
-    const processPromises = [];
-    // First, process default locale files (from source files)
-    // This is needed because they might not be in the fileMapping if they're not being translated
-    // Only process default locale if it's in the target locales filter
-    if (!fileMapping[settings.defaultLocale] &&
-        locales.includes(settings.defaultLocale) &&
-        !includeFiles // when filtering, skip default-locale pass
-    ) {
-        const defaultLocaleFiles = [];
-        // Collect all .md and .mdx files from sourceFiles
-        if (sourceFiles.md) {
-            defaultLocaleFiles.push(...sourceFiles.md);
-        }
-        if (sourceFiles.mdx) {
-            defaultLocaleFiles.push(...sourceFiles.mdx);
-        }
-        if (defaultLocaleFiles.length > 0) {
-            const defaultPromise = Promise.all(defaultLocaleFiles.map(async (filePath) => {
-                // Check if file exists before processing
-                if (!fs.existsSync(filePath)) {
-                    return;
-                }
-                // Get file content
-                const fileContent = await fs.promises.readFile(filePath, 'utf8');
-                // Localize the file using default locale
-                const result = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, settings.defaultLocale, // Process as default locale
-                settings.options?.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls, settings.options?.baseDomain);
-                // Only write the file if there were changes
-                if (result.hasChanges) {
-                    await fs.promises.writeFile(filePath, result.content);
-                }
-            }));
-            processPromises.push(defaultPromise);
-        }
-    }
-    // Then process all other locales from fileMapping
-    const mappingPromises = Object.entries(fileMapping)
-        .filter(([locale, filesMap]) => locales.includes(locale)) // Filter by target locales
-        .map(async ([locale, filesMap]) => {
-        // Get all files that are md or mdx
-        const targetFiles = Object.values(filesMap).filter((p) => (p.endsWith('.md') || p.endsWith('.mdx')) &&
-            (!includeFiles || includeFiles.has(p)));
-        // Replace the placeholder path with the target path
-        await Promise.all(targetFiles.map(async (filePath) => {
-            // Check if file exists before processing
-            if (!fs.existsSync(filePath)) {
-                return;
-            }
-            // Get file content
-            const fileContent = await fs.promises.readFile(filePath, 'utf8');
-            // Localize the file (handles both URLs and hrefs in single AST pass)
-            const result = localizeStaticUrlsForFile(fileContent, settings.defaultLocale, locale, settings.options?.experimentalHideDefaultLocale || false, settings.options?.docsUrlPattern, settings.options?.excludeStaticUrls, settings.options?.baseDomain);
-            // Only write the file if there were changes
-            if (result.hasChanges) {
-                await fs.promises.writeFile(filePath, result.content);
-            }
-        }));
-    });
-    processPromises.push(...mappingPromises);
-    await Promise.all(processPromises);
-}
-/**
- * Determines if a URL should be processed based on pattern matching
- */
-function shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale, baseDomain) {
-    // Check fragment-only URLs like "#id-name"
-    if (/^\s*#/.test(originalUrl)) {
-        return false;
-    }
-    const patternWithoutSlash = patternHead.replace(/\/$/, '');
-    // Handle absolute URLs with baseDomain
-    let urlToCheck = originalUrl;
-    if (baseDomain && originalUrl.startsWith(baseDomain)) {
-        urlToCheck = originalUrl.substring(baseDomain.length);
-    }
-    if (targetLocale === defaultLocale) {
-        // For default locale processing, check if URL contains the pattern
-        return urlToCheck.includes(patternWithoutSlash);
-    }
-    else {
-        // For non-default locales, check if URL starts with pattern
-        return urlToCheck.startsWith(patternWithoutSlash);
-    }
-}
-/**
- * Determines if a URL should be processed based on the base domain
- */
-function shouldProcessAbsoluteUrl(originalUrl, baseDomain) {
-    return originalUrl.startsWith(baseDomain);
-}
-/**
- * Checks if a URL should be excluded based on exclusion patterns
- */
-function isUrlExcluded(originalUrl, exclude, defaultLocale) {
-    const excludePatterns = exclude.map((p) => p.replace(/\[locale\]/g, defaultLocale));
-    return excludePatterns.some((pattern) => isMatch(originalUrl, pattern));
-}
-/**
- * Main URL transformation function that delegates to specific scenarios
- */
-export function transformUrlPath(originalUrl, patternHead, targetLocale, defaultLocale, hideDefaultLocale) {
-    const originalPathArray = originalUrl
-        .split('/')
-        .filter((path) => path !== '');
-    const patternHeadArray = patternHead.split('/').filter((path) => path !== '');
-    // check if the pattern head matches the original path
-    if (!checkIfPathMatchesPattern(originalPathArray, patternHeadArray)) {
-        return null;
-    }
-    if (patternHeadArray.length > originalPathArray.length) {
-        return null; // Pattern is longer than the URL path
-    }
-    let result = null;
-    if (targetLocale === defaultLocale) {
-        if (hideDefaultLocale) {
-            // check if default locale is already present
-            if (originalPathArray?.[patternHeadArray.length] !== defaultLocale) {
-                return null;
-            }
-            // remove default locale
-            const newPathArray = [
-                ...originalPathArray.slice(0, patternHeadArray.length),
-                ...originalPathArray.slice(patternHeadArray.length + 1),
-            ];
-            result = newPathArray.join('/');
-        }
-        else {
-            // check if default locale is already present
-            if (originalPathArray?.[patternHeadArray.length] === defaultLocale) {
-                return null;
-            }
-            // insert default locale
-            const newPathArray = [
-                ...originalPathArray.slice(0, patternHeadArray.length),
-                defaultLocale,
-                ...originalPathArray.slice(patternHeadArray.length),
-            ];
-            result = newPathArray.join('/');
-        }
-    }
-    else if (hideDefaultLocale) {
-        // Avoid duplicating target locale if already present
-        if (originalPathArray?.[patternHeadArray.length] === targetLocale) {
-            return null;
-        }
-        const newPathArray = [
-            ...originalPathArray.slice(0, patternHeadArray.length),
-            targetLocale,
-            ...originalPathArray.slice(patternHeadArray.length),
-        ];
-        result = newPathArray.join('/');
-    }
-    else {
-        // check default locale
-        if (originalPathArray?.[patternHeadArray.length] !== defaultLocale) {
-            return null;
-        }
-        // replace default locale with target locale
-        const newPathArray = [...originalPathArray];
-        newPathArray[patternHeadArray.length] = targetLocale;
-        result = newPathArray.join('/');
-    }
-    // check for leading and trailing slashes
-    if (originalUrl.startsWith('/')) {
-        result = '/' + result;
-    }
-    if (originalUrl.endsWith('/')) {
-        result = result + '/';
-    }
-    return result;
-}
-/**
- * AST-based transformation for MDX files using remark-mdx
- */
-function transformMdxUrls(mdxContent, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', exclude = [], baseDomain) {
-    const transformedUrls = [];
-    if (!pattern.startsWith('/')) {
-        pattern = '/' + pattern;
-    }
-    const patternHead = pattern.split('[locale]')[0];
-    // Quick check: if the file doesn't contain the pattern, skip expensive AST parsing
-    // For default locale processing, we also need to check if content might need adjustment
-    if (targetLocale === defaultLocale) {
-        // For default locale files, we always need to check as we're looking for either:
-        // - paths without locale (when hideDefaultLocale=false)
-        // - paths with default locale (when hideDefaultLocale=true)
-        const patternWithoutSlash = patternHead.replace(/\/$/, '');
-        if (!mdxContent.includes(patternWithoutSlash)) {
-            return {
-                content: mdxContent,
-                hasChanges: false,
-                transformedUrls: [],
-            };
-        }
-    }
-    else {
-        // For non-default locales, use the original logic
-        if (!mdxContent.includes(patternHead.replace(/\/$/, ''))) {
-            return {
-                content: mdxContent,
-                hasChanges: false,
-                transformedUrls: [],
-            };
-        }
-    }
-    // Parse the MDX content into an AST
-    let processedAst;
-    try {
-        const parseProcessor = unified()
-            .use(remarkParse)
-            .use(remarkFrontmatter, ['yaml', 'toml'])
-            .use(remarkMdx);
-        const ast = parseProcessor.parse(mdxContent);
-        processedAst = parseProcessor.runSync(ast);
-    }
-    catch {
-        return {
-            content: mdxContent,
-            hasChanges: false,
-            transformedUrls,
-        };
-    }
-    // Helper function to transform URL based on pattern
-    const transformUrl = (originalUrl, linkType) => {
-        // For Markdown links [text](path), only process absolute-root paths starting with '/'
-        // Relative markdown links should remain relative to the current page and not be localized.
-        if (linkType === 'markdown') {
-            const isFragment = /^\s*#/.test(originalUrl);
-            const isAbsoluteRoot = originalUrl.startsWith('/');
-            const looksAbsoluteWithDomain = baseDomain
-                ? shouldProcessAbsoluteUrl(originalUrl, baseDomain)
-                : false;
-            if (!isAbsoluteRoot && !looksAbsoluteWithDomain && !isFragment) {
-                return null;
-            }
-        }
-        // Check if URL should be processed
-        if (!shouldProcessUrl(originalUrl, patternHead, targetLocale, defaultLocale, baseDomain)) {
-            return null;
-        }
-        // Skip absolute URLs (http://, https://, //, etc.)
-        if (baseDomain && shouldProcessAbsoluteUrl(originalUrl, baseDomain)) {
-            // Get everything after the base domain
-            const afterDomain = originalUrl.substring(baseDomain.length);
-            const transformedPath = transformUrlPath(afterDomain, patternHead, targetLocale, defaultLocale, hideDefaultLocale);
-            if (!transformedPath) {
-                return null;
-            }
-            transformedUrls.push({
-                originalPath: originalUrl,
-                newPath: transformedPath,
-                type: linkType,
-            });
-            return transformedPath ? baseDomain + transformedPath : null;
-        }
-        // Exclude colon-prefixed URLs (http://, https://, //, etc.)
-        if (originalUrl.split('?')[0].includes(':')) {
-            return null;
-        }
-        // Transform the URL based on locale and configuration
-        const newUrl = transformUrlPath(originalUrl, patternHead, targetLocale, defaultLocale, hideDefaultLocale);
-        if (!newUrl) {
-            return null;
-        }
-        // Check exclusions
-        if (isUrlExcluded(originalUrl, exclude, defaultLocale)) {
-            return null;
-        }
-        transformedUrls.push({
-            originalPath: originalUrl,
-            newPath: newUrl,
-            type: linkType,
-        });
-        return newUrl;
-    };
-    // Visit markdown link nodes: [text](url)
-    visit(processedAst, 'link', (node) => {
-        if (node.url) {
-            const newUrl = transformUrl(node.url, 'markdown');
-            if (newUrl) {
-                node.url = newUrl;
-            }
-        }
-    });
-    // Visit JSX/HTML elements for href attributes: <a href="url"> or <Card href="url">
-    visit(processedAst, ['mdxJsxFlowElement', 'mdxJsxTextElement'], (node) => {
-        const jsxNode = node;
-        if (jsxNode.attributes) {
-            for (const attr of jsxNode.attributes) {
-                if (attr.type === 'mdxJsxAttribute' &&
-                    attr.name === 'href' &&
-                    attr.value) {
-                    // Handle MdxJsxAttribute with string or MdxJsxAttributeValueExpression
-                    const hrefValue = typeof attr.value === 'string' ? attr.value : attr.value.value;
-                    if (typeof hrefValue === 'string') {
-                        const newUrl = transformUrl(hrefValue, 'href');
-                        if (newUrl) {
-                            if (typeof attr.value === 'string') {
-                                attr.value = newUrl;
-                            }
-                            else {
-                                attr.value.value = newUrl;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    });
-    // Visit raw JSX nodes for href attributes in JSX strings
-    visit(processedAst, 'jsx', (node) => {
-        if (node.value && typeof node.value === 'string') {
-            const jsxContent = node.value;
-            // Use regex to find href attributes in the JSX string
-            const hrefRegex = /href\s*=\s*["']([^"']+)["']/g;
-            let match;
-            const replacements = [];
-            // Reset regex lastIndex to avoid issues with global flag
-            hrefRegex.lastIndex = 0;
-            while ((match = hrefRegex.exec(jsxContent)) !== null) {
-                const originalHref = match[1];
-                const newUrl = transformUrl(originalHref, 'href');
-                if (newUrl) {
-                    // Store replacement info
-                    const oldHrefAttr = match[0]; // The full match like 'href="/quickstart"'
-                    const quote = oldHrefAttr.includes('"') ? '"' : "'";
-                    const newHrefAttr = `href=${quote}${newUrl}${quote}`;
-                    replacements.push({
-                        start: match.index,
-                        end: match.index + oldHrefAttr.length,
-                        oldHrefAttr,
-                        newHrefAttr,
-                    });
-                }
-            }
-            // Apply replacements in reverse order (from end to start) to avoid position shifts
-            if (replacements.length > 0) {
-                let newJsxContent = jsxContent;
-                replacements
-                    .sort((a, b) => b.start - a.start)
-                    .forEach(({ start, end, newHrefAttr }) => {
-                    newJsxContent =
-                        newJsxContent.slice(0, start) +
-                            newHrefAttr +
-                            newJsxContent.slice(end);
-                });
-                node.value = newJsxContent;
-            }
-        }
-    });
-    // Convert the modified AST back to MDX string
-    let content;
-    try {
-        const stringifyProcessor = unified()
-            .use(remarkFrontmatter, ['yaml', 'toml'])
-            .use(remarkMdx)
-            .use(normalizeCJKCharacters)
-            .use(escapeHtmlInTextNodes)
-            .use(remarkStringify, {
-            handlers: {
-                // Handler to prevent escaping (avoids '&lt;' -> '\&lt;')
-                text(node) {
-                    return node.value;
-                },
-            },
-        });
-        const outTree = stringifyProcessor.runSync(processedAst);
-        content = stringifyProcessor.stringify(outTree);
-    }
-    catch (error) {
-        console.warn(`Failed to stringify MDX content: ${error instanceof Error ? error.message : String(error)}`);
-        console.warn('Returning original content unchanged due to stringify error.');
-        return {
-            content: mdxContent,
-            hasChanges: false,
-            transformedUrls: [],
-        };
-    }
-    // Handle newline formatting to match original input
-    if (content.endsWith('\n') && !mdxContent.endsWith('\n')) {
-        content = content.slice(0, -1);
-    }
-    // Preserve leading newlines from original content
-    if (mdxContent.startsWith('\n') && !content.startsWith('\n')) {
-        content = '\n' + content;
-    }
-    return {
-        content,
-        hasChanges: transformedUrls.length > 0,
-        transformedUrls,
-    };
-}
-// AST-based transformation for MDX files using remark
-function localizeStaticUrlsForFile(file, defaultLocale, targetLocale, hideDefaultLocale, pattern = '/[locale]', // eg /docs/[locale] or /[locale]
-exclude = [], baseDomain) {
-    // Use AST-based transformation for MDX files
-    return transformMdxUrls(file, defaultLocale, targetLocale, hideDefaultLocale, pattern, exclude, baseDomain || '');
-}
-function cleanPath(path) {
-    let cleanedPath = path.startsWith('/') ? path.slice(1) : path;
-    cleanedPath = cleanedPath.endsWith('/')
-        ? cleanedPath.slice(0, -1)
-        : cleanedPath;
-    return cleanedPath;
-}
-function checkIfPathMatchesPattern(originalUrlArray, patternHeadArray) {
-    // check if the pattern head matches the original path
-    for (let i = 0; i < patternHeadArray.length; i++) {
-        if (patternHeadArray[i] !== originalUrlArray?.[i]) {
-            return false;
-        }
-    }
-    return true;
-}

package/dist/utils/mintlifyTitleFallback.d.ts

@@ -1,6 +0,0 @@
-type TitleFallbackResult = {
-    content: string;
-    addedTitle: boolean;
-};
-export declare function applyMintlifyTitleFallback(content: string, fileName: string, defaultLocale?: string): TitleFallbackResult;
-export {};

package/dist/utils/mintlifyTitleFallback.js

@@ -1,80 +0,0 @@
-import path from 'path';
-import YAML from 'yaml';
-const FRONTMATTER_REGEX = /^---\s*\r?\n([\s\S]*?)\r?\n(---|\.\.\.)\s*(?:\r?\n|$)/;
-function toTitleCase(value) {
-    return value
-        .split(' ')
-        .map((word) => {
-        if (!word)
-            return '';
-        return word[0].toUpperCase() + word.slice(1);
-    })
-        .join(' ');
-}
-function deriveTitleFromFilename(fileName, defaultLocale) {
-    const base = path.basename(fileName, path.extname(fileName));
-    if (base.toLowerCase() === 'index') {
-        const parentDir = path.dirname(fileName);
-        if (parentDir === '.' || parentDir === path.sep) {
-            return 'Index';
-        }
-        const parent = path.basename(parentDir);
-        if (parent && defaultLocale && parent === defaultLocale) {
-            return 'Index';
-        }
-        if (parent) {
-            return toTitleCase(parent.replace(/[-_]+/g, ' ').trim());
-        }
-        return 'Index';
-    }
-    const normalized = base.replace(/[-_]+/g, ' ').replace(/\s+/g, ' ').trim();
-    if (!normalized) {
-        return base;
-    }
-    return toTitleCase(normalized);
-}
-function hasMeaningfulTitle(value) {
-    if (value === null || value === undefined) {
-        return false;
-    }
-    if (typeof value === 'string') {
-        return value.trim().length > 0;
-    }
-    return true;
-}
-export function applyMintlifyTitleFallback(content, fileName, defaultLocale) {
-    const inferredTitle = deriveTitleFromFilename(fileName, defaultLocale);
-    if (!inferredTitle) {
-        return { content, addedTitle: false };
-    }
-    const hasBom = content.startsWith('\uFEFF');
-    const contentBody = hasBom ? content.slice(1) : content;
-    const newline = contentBody.includes('\r\n') ? '\r\n' : '\n';
-    const frontmatterMatch = contentBody.match(FRONTMATTER_REGEX);
-    if (frontmatterMatch) {
-        const frontmatterContent = frontmatterMatch[1];
-        let parsed;
-        try {
-            parsed = YAML.parse(frontmatterContent);
-        }
-        catch {
-            return { content, addedTitle: false };
-        }
-        if (parsed && hasMeaningfulTitle(parsed.title)) {
-            return { content, addedTitle: false };
-        }
-        const titleLine = YAML.stringify({ title: inferredTitle }).trimEnd();
-        const headerEndIndex = contentBody.indexOf(newline) + newline.length;
-        const updated = contentBody.slice(0, headerEndIndex) +
-            titleLine +
-            newline +
-            contentBody.slice(headerEndIndex);
-        return { content: (hasBom ? '\uFEFF' : '') + updated, addedTitle: true };
-    }
-    const titleLine = YAML.stringify({ title: inferredTitle }).trimEnd();
-    const frontmatterBlock = `---${newline}${titleLine}${newline}---${newline}${newline}`;
-    return {
-        content: (hasBom ? '\uFEFF' : '') + frontmatterBlock + contentBody,
-        addedTitle: true,
-    };
-}

package/dist/utils/parse/needsCJS.d.ts

@@ -1,20 +0,0 @@
-import { ParseResult } from '@babel/parser';
-import * as t from '@babel/types';
-/**
- * Given an AST determines if the file needs to be compiled as CommonJS or ESM.
- * @param ast - The AST to analyze
- * @returns True if the file needs to be compiled as CommonJS, false if it needs to be compiled as ESM
- */
-export declare function needsCJS({ ast, warnings, filepath, packageJson, tsconfigJson, }: {
-    ast: ParseResult<t.File>;
-    warnings: string[];
-    filepath: string;
-    packageJson?: {
-        type?: string;
-    };
-    tsconfigJson?: {
-        compilerOptions?: {
-            module?: string;
-        };
-    };
-}): boolean;

package/dist/utils/parse/needsCJS.js

@@ -1,72 +0,0 @@
-import traverseModule from '@babel/traverse';
-import * as t from '@babel/types';
-// Handle CommonJS/ESM interop
-const traverse = traverseModule.default || traverseModule;
-/**
- * Given an AST determines if the file needs to be compiled as CommonJS or ESM.
- * @param ast - The AST to analyze
- * @returns True if the file needs to be compiled as CommonJS, false if it needs to be compiled as ESM
- */
-export function needsCJS({ ast, warnings, filepath, packageJson, tsconfigJson, }) {
-    // Analyze the actual file content to determine module system
-    let hasES6Imports = false;
-    let hasCommonJSRequire = false;
-    traverse(ast, {
-        ImportDeclaration() {
-            hasES6Imports = true;
-        },
-        CallExpression(path) {
-            if (t.isIdentifier(path.node.callee, { name: 'require' })) {
-                hasCommonJSRequire = true;
-            }
-        },
-    });
-    // Determine if we need CommonJS based on actual file content and fallback to config-based logic
-    let needsCJS = false;
-    if (hasES6Imports && !hasCommonJSRequire) {
-        // File uses ES6 imports, so we should use ES6 imports
-        needsCJS = false;
-    }
-    else if (hasCommonJSRequire && !hasES6Imports) {
-        // File uses CommonJS require, so we should use CommonJS require
-        needsCJS = true;
-    }
-    else if (hasES6Imports && hasCommonJSRequire) {
-        // Mixed usage - this is unusual but we'll default to ES6 imports
-        warnings.push(`Mixed ES6 imports and CommonJS require detected in ${filepath}. Defaulting to ES6 imports.`);
-        needsCJS = false;
-    }
-    else {
-        // No imports/requires found, fall back to configuration-based logic
-        if (filepath.endsWith('.ts') || filepath.endsWith('.tsx')) {
-            // For TypeScript files, check tsconfig.json compilerOptions.module
-            const moduleSetting = tsconfigJson?.compilerOptions?.module;
-            if (moduleSetting === 'commonjs' || moduleSetting === 'node') {
-                needsCJS = true;
-            }
-            else if (moduleSetting === 'esnext' ||
-                moduleSetting === 'es2022' ||
-                moduleSetting === 'es2020' ||
-                moduleSetting === 'es2015' ||
-                moduleSetting === 'es6' ||
-                moduleSetting === 'node16' ||
-                moduleSetting === 'nodenext') {
-                needsCJS = false;
-            }
-            else {
-                // Default to ESM for TypeScript files if no module setting is specified
-                needsCJS = false;
-            }
-        }
-        else if (filepath.endsWith('.js')) {
-            // For JavaScript files, check package.json type
-            // If package.json has "type": "module", .js files are treated as ES modules
-            needsCJS = packageJson?.type !== 'module';
-        }
-        else {
-            // For other file extensions, default to ESM
-            needsCJS = false;
-        }
-    }
-    return needsCJS;
-}

package/dist/utils/persistPostprocessHashes.d.ts

@@ -1,12 +0,0 @@
-import type { Settings } from '../types/index.js';
-type DownloadMeta = {
-    branchId: string;
-    fileId: string;
-    versionId: string;
-    locale: string;
-};
-/**
- * Persist postprocessed content hashes for recently downloaded files into gt-lock.json.
- */
-export declare function persistPostProcessHashes(settings: Settings, includeFiles: Set<string> | undefined, downloadedMeta: Map<string, DownloadMeta>): void;
-export {};

package/dist/utils/persistPostprocessHashes.js

@@ -1,39 +0,0 @@
-import * as fs from 'node:fs';
-import { ensureNestedObject, getDownloadedVersions, saveDownloadedVersions, } from '../fs/config/downloadedVersions.js';
-import { hashStringSync } from './hash.js';
-/**
- * Persist postprocessed content hashes for recently downloaded files into gt-lock.json.
- */
-export function persistPostProcessHashes(settings, includeFiles, downloadedMeta) {
-    if (!includeFiles || includeFiles.size === 0 || downloadedMeta.size === 0) {
-        return;
-    }
-    const downloadedVersions = getDownloadedVersions(settings.configDirectory);
-    let lockUpdated = false;
-    for (const filePath of includeFiles) {
-        const meta = downloadedMeta.get(filePath);
-        if (!meta)
-            continue;
-        if (!fs.existsSync(filePath))
-            continue;
-        const content = fs.readFileSync(filePath, 'utf8');
-        const hash = hashStringSync(content);
-        ensureNestedObject(downloadedVersions.entries, [
-            meta.branchId,
-            meta.fileId,
-            meta.versionId,
-            meta.locale,
-        ]);
-        const existing = downloadedVersions.entries[meta.branchId][meta.fileId][meta.versionId][meta.locale] || {};
-        if (existing.postProcessHash !== hash) {
-            downloadedVersions.entries[meta.branchId][meta.fileId][meta.versionId][meta.locale] = {
-                ...existing,
-                postProcessHash: hash,
-            };
-            lockUpdated = true;
-        }
-    }
-    if (lockUpdated) {
-        saveDownloadedVersions(settings.configDirectory, downloadedVersions);
-    }
-}