gtx-cli 2.0.17 → 2.0.19

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # gtx-cli
 
+## 2.0.19
+
+### Patch Changes
+
+- [#519](https://github.com/generaltranslation/gt/pull/519) [`2ba4848`](https://github.com/generaltranslation/gt/commit/2ba48486603ef5e8e4026d89dc36311ce6505b81) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - feat: exclude files with the [locales] tag
+
+## 2.0.18
+
+### Patch Changes
+
+- [#507](https://github.com/generaltranslation/gt/pull/507) [`8f80795`](https://github.com/generaltranslation/gt/commit/8f80795daf862f769be728c044d48e5e28d7b126) Thanks [@SamEggert](https://github.com/SamEggert)! - Setup wizard detects and matches your module system when modifying the next.config
+
+- [#517](https://github.com/generaltranslation/gt/pull/517) [`452da1e`](https://github.com/generaltranslation/gt/commit/452da1e1f0f6d7825b82bc66fb5d3dd6e7a6ad92) Thanks [@ErnestM1234](https://github.com/ErnestM1234)! - feat: add support for yaml
+
 ## 2.0.17
 
 ### Patch Changes

package/dist/api/downloadFile.js

@@ -5,6 +5,8 @@ import { gt } from '../utils/gt.js';
 import { validateJsonSchema } from '../formats/json/utils.js';
 import { mergeJson } from '../formats/json/mergeJson.js';
 import { TextDecoder } from 'node:util';
+import mergeYaml from '../formats/yaml/mergeYaml.js';
+import { validateYamlSchema } from '../formats/yaml/utils.js';
 /**
  * Downloads a file from the API and saves it to a local directory
  * @param translationId - The ID of the translation to download
@@ -38,6 +40,20 @@ export async function downloadFile(translationId, outputPath, inputPath, locale,
                     }
                 }
             }
+            if (options.options?.yamlSchema && locale) {
+                const yamlSchema = validateYamlSchema(options.options, outputPath);
+                if (yamlSchema) {
+                    const originalContent = fs.readFileSync(outputPath, 'utf8');
+                    if (originalContent) {
+                        data = mergeYaml(originalContent, outputPath, options.options, [
+                            {
+                                translatedContent: data,
+                                targetLocale: locale,
+                            },
+                        ])[0];
+                    }
+                }
+            }
             // Write the file to disk
             await fs.promises.writeFile(outputPath, data);
             return true;

package/dist/api/downloadFileBatch.js

@@ -3,7 +3,9 @@ import * as path from 'path';
 import { logError, logWarning } from '../console/logging.js';
 import { gt } from '../utils/gt.js';
 import { validateJsonSchema } from '../formats/json/utils.js';
+import { validateYamlSchema } from '../formats/yaml/utils.js';
 import { mergeJson } from '../formats/json/mergeJson.js';
+import mergeYaml from '../formats/yaml/mergeYaml.js';
 /**
  * Downloads multiple translation files in a single batch request
  * @param files - Array of files to download with their output paths
@@ -56,6 +58,20 @@ export async function downloadFileBatch(files, options, maxRetries = 3, retryDel
                             }
                         }
                     }
+                    if (options.options?.yamlSchema && locale) {
+                        const yamlSchema = validateYamlSchema(options.options, inputPath);
+                        if (yamlSchema) {
+                            const originalContent = fs.readFileSync(inputPath, 'utf8');
+                            if (originalContent) {
+                                data = mergeYaml(originalContent, inputPath, options.options, [
+                                    {
+                                        translatedContent: file.data,
+                                        targetLocale: locale,
+                                    },
+                                ])[0];
+                            }
+                        }
+                    }
                     // Write the file to disk
                     await fs.promises.writeFile(outputPath, data);
                     result.successful.push(translationId);

package/dist/config/generateSettings.js

@@ -105,17 +105,30 @@ export async function generateSettings(options, cwd = process.cwd()) {
     mergedOptions.src = mergedOptions.src || DEFAULT_SRC_PATTERNS;
     // Resolve all glob patterns in the files object
     mergedOptions.files = mergedOptions.files
-        ? resolveFiles(mergedOptions.files, mergedOptions.defaultLocale, cwd)
+        ? resolveFiles(mergedOptions.files, mergedOptions.defaultLocale, mergedOptions.locales, cwd)
         : undefined;
     // Add additional options if provided
-    if (mergedOptions.options && mergedOptions.options.jsonSchema) {
-        for (const fileGlob of Object.keys(mergedOptions.options.jsonSchema)) {
-            const jsonSchema = mergedOptions.options.jsonSchema[fileGlob];
-            if (jsonSchema.preset) {
-                mergedOptions.options.jsonSchema[fileGlob] = {
-                    ...generatePreset(jsonSchema.preset),
-                    ...jsonSchema,
-                };
+    if (mergedOptions.options) {
+        if (mergedOptions.options.jsonSchema) {
+            for (const fileGlob of Object.keys(mergedOptions.options.jsonSchema)) {
+                const jsonSchema = mergedOptions.options.jsonSchema[fileGlob];
+                if (jsonSchema.preset) {
+                    mergedOptions.options.jsonSchema[fileGlob] = {
+                        ...generatePreset(jsonSchema.preset, 'json'),
+                        ...jsonSchema,
+                    };
+                }
+            }
+        }
+        if (mergedOptions.options.yamlSchema) {
+            for (const fileGlob of Object.keys(mergedOptions.options.yamlSchema)) {
+                const yamlSchema = mergedOptions.options.yamlSchema[fileGlob];
+                if (yamlSchema.preset) {
+                    mergedOptions.options.yamlSchema[fileGlob] = {
+                        ...generatePreset(yamlSchema.preset, 'yaml'),
+                        ...yamlSchema,
+                    };
+                }
             }
         }
     }

package/dist/config/optionPresets.d.ts

@@ -1,2 +1,2 @@
-import { JsonSchema } from '../types/index.js';
-export declare function generatePreset(preset: string): JsonSchema;
+import { JsonSchema, YamlSchema } from '../types/index.js';
+export declare function generatePreset(preset: string, type: 'json' | 'yaml'): JsonSchema | YamlSchema;

package/dist/config/optionPresets.js

@@ -1,44 +1,56 @@
-export function generatePreset(preset) {
-    switch (preset) {
-        case 'mintlify':
-            // https://mintlify.com/docs/navigation
-            return {
-                composite: {
-                    '$.navigation.languages': {
-                        type: 'array',
-                        key: '$.language',
-                        include: [
-                            '$..group',
-                            '$..tab',
-                            '$..item',
-                            '$..anchor',
-                            '$..dropdown',
-                        ],
-                        transform: {
-                            '$..pages[*]': {
-                                match: '^{locale}/(.*)$',
-                                replace: '{locale}/$1',
+export function generatePreset(preset, type) {
+    if (type === 'json') {
+        switch (preset) {
+            case 'mintlify':
+                // https://mintlify.com/docs/navigation
+                return {
+                    composite: {
+                        '$.navigation.languages': {
+                            type: 'array',
+                            key: '$.language',
+                            include: [
+                                '$..group',
+                                '$..tab',
+                                '$..item',
+                                '$..anchor',
+                                '$..dropdown',
+                            ],
+                            transform: {
+                                '$..pages[*]': {
+                                    match: '^{locale}/(.*)$',
+                                    replace: '{locale}/$1',
+                                },
                             },
                         },
-                    },
-                    '$.redirects': {
-                        type: 'array',
-                        key: '$.language',
-                        include: [],
-                        transform: {
-                            '$.source': {
-                                match: '^/{locale}/(.*)$',
-                                replace: '/{locale}/$1',
-                            },
-                            '$.destination': {
-                                match: '^/{locale}/(.*)$',
-                                replace: '/{locale}/$1',
+                        '$.redirects': {
+                            type: 'array',
+                            key: '$.language',
+                            include: [],
+                            transform: {
+                                '$.source': {
+                                    match: '^/{locale}/(.*)$',
+                                    replace: '/{locale}/$1',
+                                },
+                                '$.destination': {
+                                    match: '^/{locale}/(.*)$',
+                                    replace: '/{locale}/$1',
+                                },
                             },
                         },
                     },
-                },
-            };
-        default:
-            return {};
+                };
+            default:
+                return {};
+        }
+    }
+    else {
+        switch (preset) {
+            case 'mintlify':
+                return {
+                    include: ['$..summary', '$..description'],
+                };
+            default:
+                return {};
+        }
     }
 }

package/dist/formats/files/supportedFiles.d.ts

@@ -1,8 +1,9 @@
-export declare const SUPPORTED_FILE_EXTENSIONS: readonly ["json", "mdx", "md", "ts", "js"];
+export declare const SUPPORTED_FILE_EXTENSIONS: readonly ["json", "mdx", "md", "ts", "js", "yaml"];
 export declare const FILE_EXT_TO_EXT_LABEL: {
     json: string;
     mdx: string;
     md: string;
     ts: string;
     js: string;
+    yaml: string;
 };

package/dist/formats/files/supportedFiles.js

@@ -4,6 +4,7 @@ export const SUPPORTED_FILE_EXTENSIONS = [
     'md',
     'ts',
     'js',
+    'yaml',
 ];
 export const FILE_EXT_TO_EXT_LABEL = {
     json: 'JSON',
@@ -11,4 +12,5 @@ export const FILE_EXT_TO_EXT_LABEL = {
     md: 'Markdown',
     ts: 'TypeScript',
     js: 'JavaScript',
+    yaml: 'YAML',
 };

package/dist/formats/files/translate.js

@@ -10,6 +10,7 @@ import { SUPPORTED_FILE_EXTENSIONS } from './supportedFiles.js';
 import sanitizeFileContent from '../../utils/sanitizeFileContent.js';
 import { parseJson } from '../json/parseJson.js';
 import { createFileMapping } from './fileMapping.js';
+import parseYaml from '../yaml/parseYaml.js';
 const SUPPORTED_DATA_FORMATS = ['JSX', 'ICU', 'I18NEXT'];
 /**
  * Sends multiple files to the API for translation
@@ -42,8 +43,26 @@ export async function translateFiles(filePaths, placeholderPaths, transformPaths
         });
         allFiles.push(...jsonFiles);
     }
+    // Process YAML files
+    if (filePaths.yaml) {
+        if (!SUPPORTED_DATA_FORMATS.includes(dataFormat)) {
+            logErrorAndExit(noSupportedFormatError);
+        }
+        const yamlFiles = filePaths.yaml.map((filePath) => {
+            const content = readFile(filePath);
+            const parsedYaml = parseYaml(content, filePath, additionalOptions);
+            const relativePath = getRelative(filePath);
+            return {
+                content: parsedYaml,
+                fileName: relativePath,
+                fileFormat: 'JSON', // Translate as a JSON file
+                dataFormat,
+            };
+        });
+        allFiles.push(...yamlFiles);
+    }
     for (const fileType of SUPPORTED_FILE_EXTENSIONS) {
-        if (fileType === 'json')
+        if (fileType === 'json' || fileType === 'yaml')
             continue;
         if (filePaths[fileType]) {
             const files = filePaths[fileType].map((filePath) => {

package/dist/formats/files/upload.js

@@ -10,6 +10,7 @@ import { parseJson } from '../json/parseJson.js';
 import { uploadFiles } from '../../api/uploadFiles.js';
 import { existsSync, readFileSync } from 'node:fs';
 import { createFileMapping } from './fileMapping.js';
+import parseYaml from '../yaml/parseYaml.js';
 const SUPPORTED_DATA_FORMATS = ['JSX', 'ICU', 'I18NEXT'];
 /**
  * Sends multiple files to the API for translation
@@ -43,8 +44,27 @@ export async function upload(filePaths, placeholderPaths, transformPaths, dataFo
         });
         allFiles.push(...jsonFiles);
     }
+    // Process YAML files
+    if (filePaths.yaml) {
+        if (!SUPPORTED_DATA_FORMATS.includes(dataFormat)) {
+            logErrorAndExit(noSupportedFormatError);
+        }
+        const yamlFiles = filePaths.yaml.map((filePath) => {
+            const content = readFile(filePath);
+            const parsedYaml = parseYaml(content, filePath, additionalOptions);
+            const relativePath = getRelative(filePath);
+            return {
+                content: parsedYaml,
+                fileName: relativePath,
+                fileFormat: 'JSON', // Translate as a JSON file
+                dataFormat,
+                locale: options.defaultLocale,
+            };
+        });
+        allFiles.push(...yamlFiles);
+    }
     for (const fileType of SUPPORTED_FILE_EXTENSIONS) {
-        if (fileType === 'json')
+        if (fileType === 'json' || fileType === 'yaml')
             continue;
         if (filePaths[fileType]) {
             const files = filePaths[fileType].map((filePath) => {

package/dist/formats/yaml/mergeYaml.d.ts

@@ -0,0 +1,5 @@
+import { AdditionalOptions } from '../../types/index.js';
+export default function mergeYaml(originalContent: string, inputPath: string, options: AdditionalOptions, targets: {
+    translatedContent: string;
+    targetLocale: string;
+}[]): string[];

package/dist/formats/yaml/mergeYaml.js

@@ -0,0 +1,55 @@
+import JSONPointer from 'jsonpointer';
+import { exit, logError } from '../../console/logging.js';
+import { validateYamlSchema } from './utils.js';
+import YAML from 'yaml';
+export default function mergeYaml(originalContent, inputPath, options, targets) {
+    const yamlSchema = validateYamlSchema(options, inputPath);
+    if (!yamlSchema) {
+        return targets.map((target) => target.translatedContent);
+    }
+    let originalYaml;
+    try {
+        originalYaml = YAML.parse(originalContent);
+    }
+    catch {
+        logError(`Invalid YAML file: ${inputPath}`);
+        exit(1);
+    }
+    // Unreachable (validated in validateYamlSchema, included for type check)
+    if (!yamlSchema.include) {
+        logError('No include property found in YAML schema');
+        exit(1);
+    }
+    // Handle include
+    const output = [];
+    for (const target of targets) {
+        // Must clone the original YAML to avoid mutations
+        const mergedYaml = JSON.parse(JSON.stringify(originalYaml));
+        let translatedJson;
+        try {
+            translatedJson = JSON.parse(target.translatedContent);
+        }
+        catch {
+            // If parsing fails, treat as empty object to avoid crashes
+            translatedJson = {};
+        }
+        for (const [jsonPointer, translatedValue] of Object.entries(translatedJson)) {
+            try {
+                // Try to get the value - if this succeeds, the pointer exists
+                if (JSONPointer.get(mergedYaml, jsonPointer) == null) {
+                    continue;
+                }
+                // Set the new value regardless of what the current value is (including null/falsy)
+                JSONPointer.set(mergedYaml, jsonPointer, translatedValue);
+            }
+            catch {
+                // Silently ignore invalid or non-existent JSON pointers
+            }
+        }
+        output.push(YAML.stringify(mergedYaml));
+    }
+    if (!output.length) {
+        return [originalContent];
+    }
+    return output;
+}

package/dist/formats/yaml/parseYaml.d.ts

@@ -0,0 +1,2 @@
+import { AdditionalOptions } from '../../types/index.js';
+export default function parseYaml(content: string, filePath: string, options: AdditionalOptions): string;

package/dist/formats/yaml/parseYaml.js

@@ -0,0 +1,23 @@
+import { exit, logError } from '../../console/logging.js';
+import YAML from 'yaml';
+import { validateYamlSchema } from './utils.js';
+import { flattenJsonWithStringFilter } from '../json/flattenJson.js';
+export default function parseYaml(content, filePath, options) {
+    const yamlSchema = validateYamlSchema(options, filePath);
+    if (!yamlSchema) {
+        return content;
+    }
+    let yaml;
+    try {
+        yaml = YAML.parse(content);
+    }
+    catch {
+        logError(`Invalid YAML file: ${filePath}`);
+        exit(1);
+    }
+    if (yamlSchema.include) {
+        const flattenedYaml = flattenJsonWithStringFilter(yaml, yamlSchema.include);
+        return JSON.stringify(flattenedYaml);
+    }
+    return content;
+}

package/dist/formats/yaml/utils.d.ts

@@ -0,0 +1,2 @@
+import { AdditionalOptions, YamlSchema } from '../../types/index.js';
+export declare function validateYamlSchema(options: AdditionalOptions, filePath: string): YamlSchema | null;

package/dist/formats/yaml/utils.js

@@ -0,0 +1,22 @@
+import { logError, exit } from '../../console/logging.js';
+import micromatch from 'micromatch';
+const { isMatch } = micromatch;
+import path from 'path';
+export function validateYamlSchema(options, filePath) {
+    if (!options.yamlSchema) {
+        return null;
+    }
+    // Check if the file matches any of the yaml schema globs
+    const fileGlobs = Object.keys(options.yamlSchema);
+    const matchingGlob = fileGlobs.find((fileGlob) => isMatch(path.relative(process.cwd(), filePath), fileGlob));
+    if (!matchingGlob || !options.yamlSchema[matchingGlob]) {
+        return null;
+    }
+    // Validate includes
+    const yamlSchema = options.yamlSchema[matchingGlob];
+    if (!yamlSchema.include) {
+        logError('No include property found in YAML schema');
+        exit(1);
+    }
+    return yamlSchema;
+}

package/dist/fs/config/parseFilesConfig.d.ts

@@ -1,4 +1,4 @@
-import { FilesOptions, ResolvedFiles, TransformFiles } from '../../types/index.js';
+import { FilesOptions, ResolvedFiles, TransformFiles, TransformOption } from '../../types/index.js';
 /**
  * Resolves the files from the files object
  * Replaces [locale] with the actual locale in the files
@@ -16,8 +16,12 @@ export declare function resolveLocaleFiles(files: ResolvedFiles, locale: string)
  * @param files - The files object
  * @returns The resolved files
  */
-export declare function resolveFiles(files: FilesOptions, locale: string, cwd: string): {
+export declare function resolveFiles(files: FilesOptions, locale: string, locales: string[], cwd: string): {
     resolvedPaths: ResolvedFiles;
     placeholderPaths: ResolvedFiles;
     transformPaths: TransformFiles;
 };
+export declare function expandGlobPatterns(cwd: string, includePatterns: string[], excludePatterns: string[], locale: string, locales: string[], transformPatterns?: TransformOption | string): {
+    resolvedPaths: string[];
+    placeholderPaths: string[];
+};

package/dist/fs/config/parseFilesConfig.js

@@ -28,7 +28,7 @@ export function resolveLocaleFiles(files, locale) {
  * @param files - The files object
  * @returns The resolved files
  */
-export function resolveFiles(files, locale, cwd) {
+export function resolveFiles(files, locale, locales, cwd) {
     // Initialize result object with empty arrays for each file type
     const result = {};
     const placeholderResult = {};
@@ -47,7 +47,7 @@ export function resolveFiles(files, locale, cwd) {
         }
         // ==== PLACEHOLDERS ==== //
         if (files[fileType]?.include) {
-            const filePaths = expandGlobPatterns(cwd, files[fileType].include, files[fileType]?.exclude || [], locale, transformPaths[fileType] || undefined);
+            const filePaths = expandGlobPatterns(cwd, files[fileType].include, files[fileType]?.exclude || [], locale, locales, transformPaths[fileType] || undefined);
             result[fileType] = filePaths.resolvedPaths;
             placeholderResult[fileType] = filePaths.placeholderPaths;
         }
@@ -59,7 +59,7 @@ export function resolveFiles(files, locale, cwd) {
     };
 }
 // Helper function to expand glob patterns
-function expandGlobPatterns(cwd, includePatterns, excludePatterns, locale, transformPatterns) {
+export function expandGlobPatterns(cwd, includePatterns, excludePatterns, locale, locales, transformPatterns) {
     // Expand glob patterns to include all matching files
     const resolvedPaths = [];
     const placeholderPaths = [];
@@ -85,7 +85,9 @@ function expandGlobPatterns(cwd, includePatterns, excludePatterns, locale, trans
         // Resolve the absolute pattern path
         const absolutePattern = path.resolve(cwd, expandedPattern);
         // Prepare exclude patterns with locale replaced
-        const expandedExcludePatterns = excludePatterns.map((p) => path.resolve(cwd, p.replace(/\[locale\]/g, locale)));
+        const expandedExcludePatterns = Array.from(new Set(excludePatterns.flatMap((p) => locales.map((targetLocale) => path.resolve(cwd, p
+            .replace(/\[locale\]/g, locale)
+            .replace(/\[locales\]/g, targetLocale))))));
         // Use fast-glob to find all matching files, excluding the patterns
         const matches = fg.sync(absolutePattern, {
             absolute: true,

package/dist/next/parse/handleInitGT.d.ts

@@ -1 +1,7 @@
-export declare function handleInitGT(filepath: string, errors: string[], warnings: string[], filesUpdated: string[]): Promise<void>;
+export declare function handleInitGT(filepath: string, errors: string[], warnings: string[], filesUpdated: string[], packageJson?: {
+    type?: string;
+}, tsconfigJson?: {
+    compilerOptions?: {
+        module?: string;
+    };
+}): Promise<void>;

package/dist/next/parse/handleInitGT.js

@@ -7,7 +7,7 @@ const traverse = traverseModule.default || traverseModule;
 const generate = generateModule.default || generateModule;
 import * as t from '@babel/types';
 import { logError } from '../../console/logging.js';
-export async function handleInitGT(filepath, errors, warnings, filesUpdated) {
+export async function handleInitGT(filepath, errors, warnings, filesUpdated, packageJson, tsconfigJson) {
     const code = await fs.promises.readFile(filepath, 'utf8');
     let ast;
     try {
@@ -17,7 +17,66 @@ export async function handleInitGT(filepath, errors, warnings, filesUpdated) {
             tokens: true,
             createParenthesizedExpressions: true,
         });
-        const needsCJS = filepath.endsWith('.js');
+        // 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;
+            }
+        }
         // Check if withGTConfig or initGT is already imported/required
         let hasGTConfig = false;
         let hasInitGT = false;
@@ -36,16 +95,48 @@ export async function handleInitGT(filepath, errors, warnings, filesUpdated) {
             },
             VariableDeclaration(path) {
                 path.node.declarations.forEach((dec) => {
-                    if (t.isVariableDeclarator(dec) &&
-                        t.isCallExpression(dec.init) &&
-                        t.isIdentifier(dec.init.callee, { name: 'require' }) &&
-                        t.isStringLiteral(dec.init.arguments[0], {
-                            value: 'gt-next/config',
-                        })) {
-                        if (t.isIdentifier(dec.id, { name: 'withGTConfig' }))
-                            hasGTConfig = true;
-                        if (t.isIdentifier(dec.id, { name: 'initGT' }))
-                            hasInitGT = true;
+                    if (t.isVariableDeclarator(dec)) {
+                        // Handle destructuring: const { withGTConfig } = require('gt-next/config')
+                        if (t.isCallExpression(dec.init) &&
+                            t.isIdentifier(dec.init.callee, { name: 'require' }) &&
+                            t.isStringLiteral(dec.init.arguments[0], {
+                                value: 'gt-next/config',
+                            })) {
+                            // Handle simple assignment: const withGTConfig = require(...)
+                            if (t.isIdentifier(dec.id, { name: 'withGTConfig' }))
+                                hasGTConfig = true;
+                            if (t.isIdentifier(dec.id, { name: 'initGT' }))
+                                hasInitGT = true;
+                            // Handle destructuring: const { withGTConfig } = require(...)
+                            if (t.isObjectPattern(dec.id)) {
+                                dec.id.properties.forEach((prop) => {
+                                    if (t.isObjectProperty(prop) &&
+                                        t.isIdentifier(prop.key) &&
+                                        t.isIdentifier(prop.value)) {
+                                        if (prop.key.name === 'withGTConfig')
+                                            hasGTConfig = true;
+                                        if (prop.key.name === 'initGT')
+                                            hasInitGT = true;
+                                    }
+                                });
+                            }
+                        }
+                        // Handle member access: const withGTConfig = require('gt-next/config').withGTConfig
+                        else if (t.isMemberExpression(dec.init) &&
+                            t.isCallExpression(dec.init.object) &&
+                            t.isIdentifier(dec.init.object.callee, { name: 'require' }) &&
+                            t.isStringLiteral(dec.init.object.arguments[0], {
+                                value: 'gt-next/config',
+                            })) {
+                            if (t.isIdentifier(dec.id, { name: 'withGTConfig' }) &&
+                                t.isIdentifier(dec.init.property, { name: 'withGTConfig' })) {
+                                hasGTConfig = true;
+                            }
+                            if (t.isIdentifier(dec.id, { name: 'initGT' }) &&
+                                t.isIdentifier(dec.init.property, { name: 'initGT' })) {
+                                hasInitGT = true;
+                            }
+                        }
                     }
                 });
             },

package/dist/setup/wizard.js

@@ -12,6 +12,7 @@ import { wrapContentNext } from '../next/parse/wrapContent.js';
 import { getPackageManager } from '../utils/packageManager.js';
 import { installPackage } from '../utils/installPackage.js';
 import { createOrUpdateConfig } from '../fs/config/setupConfig.js';
+import { loadConfig } from '../fs/config/loadConfig.js';
 export async function handleSetupReactCommand(options) {
     // Ask user for confirmation using inquirer
     const answer = await promptConfirm({
@@ -111,8 +112,11 @@ Please let us know what you would like to see supported at https://github.com/ge
         filesUpdated = [...filesUpdated, ...filesUpdatedNext];
         spinner.stop(chalk.green(`Success! Added <T> tags and updated ${chalk.bold.cyan(filesUpdated.length)} files:\n`) + filesUpdated.map((file) => `${chalk.green('-')} ${file}`).join('\n'));
         if (addWithGTConfig) {
+            // Read tsconfig.json if it exists
+            const tsconfigPath = findFilepath(['tsconfig.json']);
+            const tsconfigJson = tsconfigPath ? loadConfig(tsconfigPath) : undefined;
             // Add the withGTConfig() function to the next.config.js file
-            await handleInitGT(nextConfigPath, errors, warnings, filesUpdated);
+            await handleInitGT(nextConfigPath, errors, warnings, filesUpdated, packageJson, tsconfigJson);
             logStep(chalk.green(`Added withGTConfig() to your ${nextConfigPath} file.`));
         }
         if (errors.length > 0) {

package/dist/types/index.d.ts

@@ -71,7 +71,7 @@ export type FilesOptions = {
     [K in SupportedFileExtension]?: {
         include: string[];
         exclude?: string[];
-        transform?: string;
+        transform?: string | TransformOption;
     };
 } & {
     gt?: {
@@ -103,6 +103,9 @@ export type AdditionalOptions = {
     jsonSchema?: {
         [fileGlob: string]: JsonSchema;
     };
+    yamlSchema?: {
+        [fileGlob: string]: YamlSchema;
+    };
     docsUrlPattern?: string;
     docsImportPattern?: string;
     docsHideDefaultLocaleImport?: boolean;
@@ -115,6 +118,10 @@ export type JsonSchema = {
         [sourceObjectPath: string]: SourceObjectOptions;
     };
 };
+export type YamlSchema = {
+    preset?: 'mintlify';
+    include?: string[];
+};
 export type SourceObjectOptions = {
     type: 'array' | 'object';
     include: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gtx-cli",
-  "version": "2.0.17",
+  "version": "2.0.19",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -88,13 +88,15 @@
     "fast-glob": "^3.3.3",
     "form-data": "^4.0.2",
     "generaltranslation": "^7.1.4",
+    "json-pointer": "^0.6.2",
     "jsonpath-plus": "^10.3.0",
     "jsonpointer": "^5.0.1",
     "micromatch": "^4.0.8",
     "open": "^10.1.1",
     "ora": "^8.2.0",
     "resolve": "^1.22.10",
-    "tsconfig-paths": "^4.2.0"
+    "tsconfig-paths": "^4.2.0",
+    "yaml": "^2.8.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",