gt 0.10.0 → 2.7.0

package/dist/utils/packageManager.js

@@ -0,0 +1,269 @@
+// This file is MIT licensed and was adapted from https://github.com/getsentry/sentry-wizard/blob/master/src/utils/package-manager.ts and https://github.com/getsentry/sentry-wizard/blob/master/src/utils/clack/index.ts
+import * as fs from 'fs';
+import * as path from 'path';
+import { getPackageJson, updatePackageJson } from './packageJson.js';
+import { promptSelect } from '../console/logging.js';
+export class NoPackageManagerError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NoPackageManagerError';
+    }
+}
+export const BUN = {
+    id: 'bun',
+    name: 'bun',
+    label: 'Bun',
+    installCommand: 'add',
+    installAllCommand: 'bun install',
+    buildCommand: 'bun run build',
+    runScriptCommand: 'bun run',
+    flags: '',
+    forceInstallFlag: '--force',
+    devDependencyFlag: '--dev',
+    detect: (cwd) => ['bun.lockb', 'bun.lock'].some((lockFile) => {
+        try {
+            return fs.existsSync(path.join(cwd, lockFile));
+        }
+        catch (e) {
+            return false;
+        }
+    }),
+    addOverride: async (pkgName, pkgVersion) => {
+        const packageDotJson = await getPackageJson();
+        if (!packageDotJson) {
+            return;
+        }
+        const overrides = packageDotJson.overrides || {};
+        await updatePackageJson({
+            ...packageDotJson,
+            overrides: {
+                ...overrides,
+                [pkgName]: pkgVersion,
+            },
+        });
+    },
+};
+export const DENO = {
+    id: 'deno',
+    name: 'deno',
+    label: 'Deno',
+    installCommand: 'install',
+    installAllCommand: 'deno install',
+    buildCommand: 'deno task build',
+    runScriptCommand: 'deno task',
+    flags: '',
+    forceInstallFlag: '--force',
+    devDependencyFlag: '--dev',
+    registry: 'npm',
+    detect: (cwd) => {
+        try {
+            return fs.existsSync(path.join(cwd, 'deno.lock'));
+        }
+        catch (e) {
+            return false;
+        }
+    },
+    addOverride: async (pkgName, pkgVersion) => {
+        const packageDotJson = await getPackageJson();
+        if (!packageDotJson) {
+            return;
+        }
+        const overrides = packageDotJson.overrides || {};
+        await updatePackageJson({
+            ...packageDotJson,
+            overrides: {
+                ...overrides,
+                [pkgName]: pkgVersion,
+            },
+        });
+    },
+};
+export const YARN_V1 = {
+    id: 'yarn_v1',
+    name: 'yarn',
+    label: 'Yarn V1',
+    installCommand: 'add',
+    installAllCommand: 'yarn install',
+    buildCommand: 'yarn build',
+    runScriptCommand: 'yarn',
+    flags: '--ignore-workspace-root-check',
+    forceInstallFlag: '--force',
+    devDependencyFlag: '--dev',
+    detect: (cwd) => {
+        try {
+            return fs
+                .readFileSync(path.join(cwd, 'yarn.lock'), 'utf-8')
+                .slice(0, 500)
+                .includes('yarn lockfile v1');
+        }
+        catch (e) {
+            return false;
+        }
+    },
+    addOverride: async (pkgName, pkgVersion) => {
+        const packageDotJson = await getPackageJson();
+        if (!packageDotJson) {
+            return;
+        }
+        const resolutions = packageDotJson.resolutions || {};
+        await updatePackageJson({
+            ...packageDotJson,
+            resolutions: {
+                ...resolutions,
+                [pkgName]: pkgVersion,
+            },
+        });
+    },
+};
+/** YARN V2/3/4 */
+export const YARN_V2 = {
+    id: 'yarn_v2',
+    name: 'yarn',
+    label: 'Yarn V2/3/4',
+    installCommand: 'add',
+    installAllCommand: 'yarn install',
+    buildCommand: 'yarn build',
+    runScriptCommand: 'yarn',
+    flags: '',
+    forceInstallFlag: '--force',
+    devDependencyFlag: '--dev',
+    detect: (cwd) => {
+        try {
+            return fs
+                .readFileSync(path.join(cwd, 'yarn.lock'), 'utf-8')
+                .slice(0, 500)
+                .includes('__metadata');
+        }
+        catch (e) {
+            return false;
+        }
+    },
+    addOverride: async (pkgName, pkgVersion) => {
+        const packageDotJson = await getPackageJson();
+        if (!packageDotJson) {
+            return;
+        }
+        const resolutions = packageDotJson.resolutions || {};
+        await updatePackageJson({
+            ...packageDotJson,
+            resolutions: {
+                ...resolutions,
+                [pkgName]: pkgVersion,
+            },
+        });
+    },
+};
+export const PNPM = {
+    id: 'pnpm',
+    name: 'pnpm',
+    label: 'PNPM',
+    installCommand: 'add',
+    installAllCommand: 'pnpm install',
+    buildCommand: 'pnpm build',
+    runScriptCommand: 'pnpm',
+    flags: '--ignore-workspace-root-check',
+    forceInstallFlag: '--force',
+    devDependencyFlag: '--save-dev',
+    detect: (cwd) => {
+        try {
+            return fs.existsSync(path.join(cwd, 'pnpm-lock.yaml'));
+        }
+        catch (e) {
+            return false;
+        }
+    },
+    addOverride: async (pkgName, pkgVersion) => {
+        const packageDotJson = await getPackageJson();
+        if (!packageDotJson) {
+            return;
+        }
+        const pnpm = packageDotJson.pnpm || {};
+        const overrides = pnpm.overrides || {};
+        await updatePackageJson({
+            ...packageDotJson,
+            pnpm: {
+                ...pnpm,
+                overrides: {
+                    ...overrides,
+                    [pkgName]: pkgVersion,
+                },
+            },
+        });
+    },
+};
+export const NPM = {
+    id: 'npm',
+    name: 'npm',
+    label: 'NPM',
+    installCommand: 'install',
+    installAllCommand: 'npm ci',
+    buildCommand: 'npm run build',
+    runScriptCommand: 'npm run',
+    flags: '',
+    forceInstallFlag: '--force',
+    devDependencyFlag: '--save-dev',
+    detect: (cwd) => {
+        try {
+            return fs.existsSync(path.join(cwd, 'package-lock.json'));
+        }
+        catch (e) {
+            return false;
+        }
+    },
+    addOverride: async (pkgName, pkgVersion) => {
+        const packageDotJson = await getPackageJson();
+        if (!packageDotJson) {
+            return;
+        }
+        const overrides = packageDotJson.overrides || {};
+        await updatePackageJson({
+            ...packageDotJson,
+            overrides: {
+                ...overrides,
+                [pkgName]: pkgVersion,
+            },
+        });
+    },
+};
+export const packageManagers = [NPM, YARN_V1, YARN_V2, PNPM, BUN, DENO];
+export function _detectPackageManger(cwd) {
+    const foundPackageMangers = packageManagers.filter((packageManager) => packageManager.detect(cwd));
+    // Only consider a package manager detected if we found exactly one.
+    // If we find more than one, we should not make any assumptions.
+    if (foundPackageMangers.length === 1) {
+        return foundPackageMangers[0];
+    }
+    return null;
+}
+// Get the package manager for the current project
+// Uses a global cache to avoid prompting the user multiple times
+export async function getPackageManager(cwd = process.cwd(), specifiedPackageManager, errorIfNotFound = false) {
+    const globalWizard = global;
+    if (globalWizard._gt_wizard_cached_package_manager) {
+        return globalWizard._gt_wizard_cached_package_manager;
+    }
+    if (specifiedPackageManager) {
+        const packageManager = packageManagers.find((packageManager) => packageManager.id === specifiedPackageManager);
+        if (packageManager) {
+            globalWizard._gt_wizard_cached_package_manager = packageManager;
+            return packageManager;
+        }
+    }
+    const detectedPackageManager = _detectPackageManger(cwd);
+    if (detectedPackageManager) {
+        globalWizard._gt_wizard_cached_package_manager = detectedPackageManager;
+        return detectedPackageManager;
+    }
+    if (errorIfNotFound) {
+        throw new NoPackageManagerError('No package manager found');
+    }
+    const selectedPackageManager = await promptSelect({
+        message: 'Please select your package manager.',
+        options: packageManagers.map((packageManager) => ({
+            value: packageManager,
+            label: packageManager.label,
+        })),
+    });
+    globalWizard._gt_wizard_cached_package_manager = selectedPackageManager;
+    return selectedPackageManager;
+}

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

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

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

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

@@ -0,0 +1,39 @@
+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);
+    }
+}

package/dist/utils/processAnchorIds.d.ts

@@ -0,0 +1,6 @@
+import { Settings } from '../types/index.js';
+/**
+ * Processes all translated MD/MDX files to add explicit anchor IDs
+ * This preserves navigation links when headings are translated
+ */
+export default function processAnchorIds(settings: Settings, includeFiles?: Set<string>): Promise<void>;

package/dist/utils/processAnchorIds.js

@@ -0,0 +1,56 @@
+import { addExplicitAnchorIds, extractHeadingInfo, } from './addExplicitAnchorIds.js';
+import { getRelative, readFile } from '../fs/findFilepath.js';
+import { createFileMapping } from '../formats/files/fileMapping.js';
+import * as fs from 'fs';
+/**
+ * Processes all translated MD/MDX files to add explicit anchor IDs
+ * This preserves navigation links when headings are translated
+ */
+export default async function processAnchorIds(settings, includeFiles) {
+    if (!settings.files)
+        return;
+    const { resolvedPaths, placeholderPaths, transformPaths } = settings.files;
+    const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
+    const sourceTypeByPath = new Map();
+    if (resolvedPaths.md) {
+        for (const filePath of resolvedPaths.md) {
+            sourceTypeByPath.set(getRelative(filePath), 'md');
+        }
+    }
+    if (resolvedPaths.mdx) {
+        for (const filePath of resolvedPaths.mdx) {
+            sourceTypeByPath.set(getRelative(filePath), 'mdx');
+        }
+    }
+    // Process each locale's translated files
+    const processPromises = Object.entries(fileMapping)
+        .filter(([locale, filesMap]) => locale !== settings.defaultLocale) // Skip default locale
+        .map(async ([locale, filesMap]) => {
+        // Get all translated files whose sources are md or mdx
+        const mdFiles = Object.entries(filesMap).filter(([sourcePath, translatedPath]) => translatedPath &&
+            sourceTypeByPath.has(sourcePath) &&
+            (!includeFiles || includeFiles.has(translatedPath)));
+        for (const [sourcePath, translatedPath] of mdFiles) {
+            try {
+                // Check if translated file exists before processing
+                if (!fs.existsSync(translatedPath)) {
+                    continue;
+                }
+                // Extract heading info from source file
+                const sourceContent = readFile(sourcePath);
+                const sourceHeadingMap = extractHeadingInfo(sourceContent);
+                const fileTypeHint = sourceTypeByPath.get(sourcePath);
+                // Read translated file and apply anchor IDs
+                const translatedContent = readFile(translatedPath);
+                const result = addExplicitAnchorIds(translatedContent, sourceHeadingMap, settings, sourcePath, translatedPath, fileTypeHint);
+                if (result.hasChanges) {
+                    fs.writeFileSync(translatedPath, result.content, 'utf8');
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to process IDs for ${translatedPath}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    });
+    await Promise.all(processPromises);
+}

package/dist/utils/processOpenApi.d.ts

@@ -0,0 +1,8 @@
+import { Settings } from '../types/index.js';
+/**
+ * Postprocess Mintlify OpenAPI references to point to locale-specific spec files.
+ * - Uses openapi.files (ordered) to resolve ambiguities (first match wins).
+ * - Relies on the user's json transform rules for locale paths.
+ * - Warns on missing/ambiguous references but keeps behavior deterministic.
+ */
+export default function processOpenApi(settings: Settings, includeFiles?: Set<string>): Promise<void>;