gt 0.10.0 → 2.7.0

package/dist/utils/localizeStaticUrls.d.ts

@@ -0,0 +1,19 @@
+import { Settings } from '../types/index.js';
+/**
+ * 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 function localizeStaticUrls(settings: Settings, targetLocales?: string[], includeFiles?: Set<string>): Promise<void>;
+/**
+ * Main URL transformation function that delegates to specific scenarios
+ */
+export declare function transformUrlPath(originalUrl: string, patternHead: string, targetLocale: string, defaultLocale: string, hideDefaultLocale: boolean): string | null;

package/dist/utils/localizeStaticUrls.js

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

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

package/dist/utils/mintlifyTitleFallback.js

@@ -0,0 +1,80 @@
+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/packageInfo.d.ts

@@ -0,0 +1,3 @@
+export declare function getPackageInfo(packageName: string): Promise<{
+    version: string;
+} | undefined>;

package/dist/utils/packageInfo.js

@@ -0,0 +1,17 @@
+import { execSync } from 'child_process';
+export async function getPackageInfo(packageName) {
+    try {
+        const output = execSync(`npm list -g ${packageName}`, {
+            encoding: 'utf8',
+            stdio: 'pipe',
+        });
+        const match = output.match(new RegExp(`${packageName}@([\\d\\.\\w-]+)`));
+        if (match && match[1]) {
+            return { version: match[1] };
+        }
+        return undefined;
+    }
+    catch (error) {
+        return undefined;
+    }
+}

package/dist/utils/packageJson.d.ts

@@ -0,0 +1,6 @@
+export declare function searchForPackageJson(cwd?: string): Promise<Record<string, any> | null>;
+export declare function getPackageJson(cwd?: string): Promise<Record<string, any> | null>;
+export declare function getCLIVersion(): string;
+export declare function updatePackageJson(packageJson: Record<string, any>, cwd?: string): Promise<void>;
+export declare function isPackageInstalled(packageName: string, packageJson: Record<string, any>, asDevDependency?: boolean, checkBoth?: boolean): boolean;
+export declare function getPackageVersion(packageName: string, packageJson: Record<string, any>): string | undefined;

package/dist/utils/packageJson.js

@@ -0,0 +1,68 @@
+import { logger } from '../console/logger.js';
+import chalk from 'chalk';
+import path from 'node:path';
+import fs from 'node:fs';
+import { exitSync } from '../console/logging.js';
+import { PACKAGE_VERSION } from '../generated/version.js';
+// search for package.json such that we can run init in non-js projects
+export async function searchForPackageJson(cwd = process.cwd()) {
+    // Get the current working directory (where the CLI is being run)
+    const packageJsonPath = path.join(cwd, 'package.json');
+    // Check if package.json exists
+    if (!fs.existsSync(packageJsonPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(await fs.promises.readFile(packageJsonPath, 'utf8'));
+    }
+    catch (error) {
+        return null;
+    }
+}
+export async function getPackageJson(cwd = process.cwd()) {
+    const packageJsonPath = path.join(cwd, 'package.json');
+    // Check if package.json exists
+    if (!fs.existsSync(packageJsonPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(await fs.promises.readFile(packageJsonPath, 'utf8'));
+    }
+    catch (error) {
+        return null;
+    }
+}
+export function getCLIVersion() {
+    return PACKAGE_VERSION;
+}
+export async function updatePackageJson(packageJson, cwd = process.cwd()) {
+    try {
+        await fs.promises.writeFile(path.join(cwd, 'package.json'), JSON.stringify(packageJson, null, 2));
+    }
+    catch (error) {
+        logger.error(chalk.red('Error updating package.json: ' + String(error)));
+        exitSync(1);
+    }
+}
+// check if a package is installed in the package.json file
+export function isPackageInstalled(packageName, packageJson, asDevDependency = false, checkBoth = false) {
+    const dependencies = checkBoth
+        ? {
+            ...packageJson.devDependencies,
+            ...packageJson.dependencies,
+        }
+        : asDevDependency
+            ? packageJson.devDependencies
+            : packageJson.dependencies;
+    if (!dependencies) {
+        return false;
+    }
+    return dependencies[packageName] !== undefined;
+}
+export function getPackageVersion(packageName, packageJson) {
+    const dependencies = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+    };
+    return dependencies[packageName] ?? undefined;
+}

package/dist/utils/packageManager.d.ts

@@ -0,0 +1,28 @@
+export interface PackageManager {
+    id: string;
+    name: string;
+    label: string;
+    installCommand: string;
+    installAllCommand: string;
+    buildCommand: string;
+    runScriptCommand: string;
+    flags: string;
+    forceInstallFlag: string;
+    devDependencyFlag: string;
+    registry?: string;
+    detect: (cwd: string) => boolean;
+    addOverride: (pkgName: string, pkgVersion: string) => Promise<void>;
+}
+export declare class NoPackageManagerError extends Error {
+    constructor(message: string);
+}
+export declare const BUN: PackageManager;
+export declare const DENO: PackageManager;
+export declare const YARN_V1: PackageManager;
+/** YARN V2/3/4 */
+export declare const YARN_V2: PackageManager;
+export declare const PNPM: PackageManager;
+export declare const NPM: PackageManager;
+export declare const packageManagers: PackageManager[];
+export declare function _detectPackageManger(cwd: string): PackageManager | null;
+export declare function getPackageManager(cwd?: string, specifiedPackageManager?: string, errorIfNotFound?: boolean): Promise<PackageManager>;