gtx-cli 2.3.6-alpha.2 → 2.3.6

package/dist/fs/findFilepath.js

@@ -0,0 +1,89 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { logError } from '../console/logging.js';
+/**
+ * Resolve the file path from the given file path or default paths.
+ * @param {string} filePath - The file path to resolve.
+ * @param {string[]} defaultPaths - The default paths to check.
+ * @returns {string} - The resolved file path.
+ */
+export default function findFilepath(paths, errorMessage = '') {
+    return findFilepaths(paths, errorMessage)?.[0] || '';
+}
+/**
+ * Resolve the file paths from the given file paths or default paths.
+ * @param {string[]} paths - The file paths to resolve.
+ * @param {string} errorMessage - The error message to throw if no paths are found.
+ * @returns {string[]} - The resolved file paths.
+ */
+export function findFilepaths(paths, errorMessage = '') {
+    const resolvedPaths = [];
+    for (const possiblePath of paths) {
+        if (fs.existsSync(possiblePath)) {
+            resolvedPaths.push(possiblePath);
+        }
+    }
+    if (errorMessage) {
+        logError(errorMessage);
+        process.exit(1);
+    }
+    return resolvedPaths;
+}
+export function getRelativePath(file, srcDirectory) {
+    // Create relative path from src directory and remove extension
+    return path
+        .relative(srcDirectory, file.replace(/\.[^/.]+$/, '') // Remove file extension
+    )
+        .replace(/\\/g, '.') // Replace Windows backslashes with dots
+        .split(/[./]/) // Split on dots or forward slashes
+        .filter(Boolean) // Remove empty segments that might cause extra dots
+        .map((segment) => segment.replace(/[^a-zA-Z0-9]/g, '_').toLowerCase()) // Convert each segment to snake case
+        .join('.'); // Rejoin with dots
+}
+/**
+ * Find a file in a directory based on a wildcard pattern.
+ * @param {string} filePattern - The wildcard pattern to search for.
+ * @param {string} file - The file to search for.
+ * @returns {string} - The path to the file.
+ */
+export function findFile(filePattern, file) {
+    // Handle wildcard pattern by replacing the wildcard with the file parameter
+    const resolvedPath = filePattern.replace(/\*/, file);
+    if (fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isFile()) {
+        return fs.readFileSync(resolvedPath, 'utf8');
+    }
+    return '';
+}
+/**
+ * Read a file and return the contents.
+ * @param {string} filePath - The path to the file to read.
+ * @returns {string} - The contents of the file.
+ */
+export function readFile(filePath) {
+    if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
+        return fs.readFileSync(filePath, 'utf8');
+    }
+    return '';
+}
+/**
+ * Find a file in a directory.
+ * @param {string} dir - The directory to search in.
+ * @param {string} file - The file to search for.
+ * @returns {string} - The path to the file.
+ */
+export function findFileInDir(dir, file) {
+    const resolvedPath = path.join(dir, file);
+    try {
+        if (fs.existsSync(resolvedPath)) {
+            return fs.readFileSync(resolvedPath, 'utf8');
+        }
+    }
+    catch (error) {
+        logError('Error finding file in directory: ' + String(error));
+    }
+    return '';
+}
+export function getRelative(absolutePath) {
+    const path2 = path.resolve(absolutePath);
+    return path.relative(process.cwd(), path2);
+}

package/dist/fs/getPackageResource.d.ts

@@ -0,0 +1 @@
+export declare function fromPackageRoot(relative: string): string;

package/dist/fs/getPackageResource.js

@@ -0,0 +1,6 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export function fromPackageRoot(relative) {
+    return path.resolve(__dirname, `../../`, relative);
+}

package/dist/fs/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fs/index.js

@@ -0,0 +1 @@
+export {};

package/dist/fs/loadJSON.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Loads a JSON file from a given filepath, returning null if the file is not found or the JSON doesn't parse.
+ * @param {string} filepath - The path to the JSON file.
+ * @returns {Record<string, any> | null} - The parsed JSON object or null if an error occurs.
+ */
+export default function loadJSON(filepath: string): Record<string, any> | null;

package/dist/fs/loadJSON.js

@@ -0,0 +1,17 @@
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ * Loads a JSON file from a given filepath, returning null if the file is not found or the JSON doesn't parse.
+ * @param {string} filepath - The path to the JSON file.
+ * @returns {Record<string, any> | null} - The parsed JSON object or null if an error occurs.
+ */
+export default function loadJSON(filepath) {
+    try {
+        const data = fs.readFileSync(path.resolve(filepath), 'utf-8');
+        return JSON.parse(data);
+    }
+    catch (error) {
+        // Return null if the file is not found or JSON parsing fails
+        return null;
+    }
+}

package/dist/fs/matchFiles.d.ts

@@ -0,0 +1 @@
+export declare function matchFiles(cwd: string, patterns: string[]): string[];

package/dist/fs/matchFiles.js

@@ -0,0 +1,8 @@
+import fg from 'fast-glob';
+export function matchFiles(cwd, patterns) {
+    return fg.sync(patterns, {
+        cwd,
+        absolute: true,
+        onlyFiles: true,
+    });
+}

package/dist/fs/saveJSON.d.ts

@@ -0,0 +1 @@
+export declare function saveJSON(filepath: string, data: Record<string, any>): Promise<void>;

package/dist/fs/saveJSON.js

@@ -0,0 +1,7 @@
+import path from 'node:path';
+import fs from 'node:fs';
+export async function saveJSON(filepath, data) {
+    // Ensure directory exists
+    await fs.promises.mkdir(path.dirname(filepath), { recursive: true });
+    await fs.promises.writeFile(filepath, JSON.stringify(data, null, 2));
+}

package/dist/fs/utils.d.ts

@@ -0,0 +1 @@
+export declare function resolveProjectId(): string | undefined;

package/dist/fs/utils.js

@@ -0,0 +1,16 @@
+export function resolveProjectId() {
+    const CANDIDATES = [
+        process.env.GT_PROJECT_ID, // any server side, Remix
+        process.env.NEXT_PUBLIC_GT_PROJECT_ID, // Next.js
+        process.env.VITE_GT_PROJECT_ID, // Vite
+        process.env.REACT_APP_GT_PROJECT_ID, // Create React App
+        process.env.REDWOOD_ENV_GT_PROJECT_ID, // RedwoodJS
+        process.env.GATSBY_GT_PROJECT_ID, // Gatsby
+        process.env.EXPO_PUBLIC_GT_PROJECT_ID, // Expo (React Native)
+        process.env.RAZZLE_GT_PROJECT_ID, // Razzle
+        process.env.UMI_GT_PROJECT_ID, // UmiJS
+        process.env.BLITZ_PUBLIC_GT_PROJECT_ID, // Blitz.js
+        process.env.PUBLIC_GT_PROJECT_ID, // WMR, Qwik (general "public" convention)
+    ];
+    return CANDIDATES.find((projectId) => projectId !== undefined);
+}

package/dist/hooks/postProcess.d.ts

@@ -0,0 +1,4 @@
+type Formatter = 'prettier' | 'biome' | 'eslint';
+export declare function detectFormatter(): Promise<Formatter | null>;
+export declare function formatFiles(filesUpdated: string[], formatter?: Formatter): Promise<void>;
+export {};

package/dist/hooks/postProcess.js

@@ -0,0 +1,110 @@
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
+import chalk from 'chalk';
+import { logMessage, logWarning } from '../console/logging.js';
+export async function detectFormatter() {
+    // Try Prettier
+    try {
+        await import('prettier');
+        return 'prettier';
+    }
+    catch { }
+    // Try ESLint
+    try {
+        await import('eslint');
+        return 'eslint';
+    }
+    catch { }
+    // Try Biome
+    try {
+        return await new Promise((resolve, reject) => {
+            const child = spawn('npx', ['@biomejs/biome', '--version'], {
+                stdio: 'ignore',
+            });
+            child.on('error', () => {
+                resolve(null);
+            });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve('biome');
+                }
+                else {
+                    resolve(null);
+                }
+            });
+        });
+    }
+    catch { }
+    return null;
+}
+export async function formatFiles(filesUpdated, formatter) {
+    if (filesUpdated.length === 0)
+        return;
+    try {
+        const detectedFormatter = formatter || (await detectFormatter());
+        if (!detectedFormatter) {
+            logWarning(chalk.yellow('No supported formatter detected'));
+            return;
+        }
+        if (detectedFormatter === 'prettier') {
+            logMessage(chalk.dim('Cleaning up with prettier...'));
+            const prettier = await import('prettier');
+            for (const file of filesUpdated) {
+                const config = await prettier.resolveConfig(file);
+                const content = await fs.promises.readFile(file, 'utf-8');
+                const formatted = await prettier.format(content, {
+                    ...config,
+                    filepath: file,
+                });
+                await fs.promises.writeFile(file, formatted);
+            }
+            return;
+        }
+        if (detectedFormatter === 'biome') {
+            logMessage(chalk.dim('Cleaning up with biome...'));
+            try {
+                await new Promise((resolve, reject) => {
+                    const args = [
+                        '@biomejs/biome',
+                        'format',
+                        '--write',
+                        ...filesUpdated.map((file) => file),
+                    ];
+                    const child = spawn('npx', args, {
+                        stdio: ['ignore', 'inherit', 'inherit'],
+                    });
+                    child.on('error', (error) => {
+                        logWarning(chalk.yellow('Biome formatting failed: ' + error.message));
+                        resolve();
+                    });
+                    child.on('close', (code) => {
+                        if (code !== 0) {
+                            logWarning(chalk.yellow(`Biome formatting failed with exit code ${code}`));
+                        }
+                        resolve();
+                    });
+                });
+            }
+            catch (error) {
+                logWarning(chalk.yellow('Biome formatting failed: ' + String(error)));
+            }
+            return;
+        }
+        if (detectedFormatter === 'eslint') {
+            logMessage(chalk.dim('Cleaning up with eslint...'));
+            const { ESLint } = await import('eslint');
+            const eslint = new ESLint({
+                fix: true,
+                overrideConfigFile: undefined, // Will use project's .eslintrc
+            });
+            for (const file of filesUpdated) {
+                const results = await eslint.lintFiles([file]);
+                await ESLint.outputFixes(results);
+            }
+            return;
+        }
+    }
+    catch (e) {
+        logWarning(chalk.yellow('Unable to run code formatter: ' + String(e)));
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { BaseCLI } from './cli/base.js';
+import { Command } from 'commander';
+export declare function main(program: Command): void;
+export { BaseCLI };

package/dist/index.js

@@ -0,0 +1,20 @@
+import { BaseCLI } from './cli/base.js';
+import { NextCLI } from './cli/next.js';
+import { ReactCLI } from './cli/react.js';
+import { determineLibrary } from './fs/determineFramework.js';
+export function main(program) {
+    const { library, additionalModules } = determineLibrary();
+    let cli;
+    if (library === 'gt-next') {
+        cli = new NextCLI(program, library, additionalModules);
+    }
+    else if (library === 'gt-react') {
+        cli = new ReactCLI(program, library, additionalModules);
+    }
+    else {
+        cli = new BaseCLI(program, library, additionalModules);
+    }
+    cli.init();
+    cli.execute();
+}
+export { BaseCLI };

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/main.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { main } from './index.js';
+import dotenv from 'dotenv';
+import { program } from 'commander';
+dotenv.config({ path: '.env' });
+dotenv.config({ path: '.env.local', override: true });
+dotenv.config({ path: '.env.production', override: true });
+main(program);
+program.parse();

package/dist/next/config/parseNextConfig.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Extracts projectId, defaultLocale, and locales from a next.config.js file.
+ * @param {string} filePath - The path to the next.config.js file.
+ * @returns {object|null} - An object containing the extracted values or null if none found or incorrect types.
+ */
+export declare function parseNextConfig(filePath: string): Promise<{
+    projectId?: string;
+    defaultLocale?: string;
+    locales?: string[];
+}>;

package/dist/next/config/parseNextConfig.js

@@ -0,0 +1,53 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { gt } from '../../utils/gt.js';
+/**
+ * Extracts projectId, defaultLocale, and locales from a next.config.js file.
+ * @param {string} filePath - The path to the next.config.js file.
+ * @returns {object|null} - An object containing the extracted values or null if none found or incorrect types.
+ */
+export async function parseNextConfig(filePath) {
+    // Resolve the absolute path
+    const absoluteFilePath = path.resolve(filePath);
+    // Check if the file exists
+    if (!fs.existsSync(absoluteFilePath)) {
+        return {};
+    }
+    // Read the file content
+    const fileContent = await fs.promises.readFile(absoluteFilePath, 'utf8');
+    // Regular expressions to extract the values
+    const defaultLocaleRegex = /defaultLocale:\s*['"]([^'"]+)['"]/;
+    const projectIdRegex = /projectId:\s*['"]([^'"]+)['"]/;
+    const localesRegex = /locales:\s*\[([^\]]+)\]/;
+    // Extract the values
+    const defaultLocaleMatch = fileContent.match(defaultLocaleRegex);
+    const projectIdMatch = fileContent.match(projectIdRegex);
+    const localesMatch = fileContent.match(localesRegex);
+    const defaultLocale = defaultLocaleMatch && typeof defaultLocaleMatch[1] === 'string'
+        ? defaultLocaleMatch[1]
+        : undefined;
+    const projectId = projectIdMatch && typeof projectIdMatch[1] === 'string'
+        ? projectIdMatch[1]
+        : undefined;
+    const locales = localesMatch
+        ? localesMatch[1]
+            .split(',')
+            .map((locale) => locale.trim().replace(/['"]/g, ''))
+            .filter((locale) => typeof locale === 'string')
+        : undefined;
+    // Ensure approvedLocales is an array of strings
+    const validLocales = locales && locales.every((locale) => gt.isValidLocale(locale))
+        ? locales
+        : undefined;
+    // Return the extracted values if they pass type checks or return null
+    if (defaultLocale || projectId || validLocales) {
+        return {
+            ...(defaultLocale && { defaultLocale }),
+            ...(projectId && { projectId }),
+            ...(validLocales && { locales: validLocales }),
+        };
+    }
+    else {
+        return {};
+    }
+}

package/dist/next/jsx/utils.d.ts

@@ -0,0 +1,7 @@
+import * as t from '@babel/types';
+import { NodePath } from '@babel/traverse';
+export declare function isHtmlElement(element: t.JSXOpeningElement): boolean;
+export declare function isBodyElement(element: t.JSXOpeningElement): boolean;
+export declare function hasGTProviderChild(element: t.JSXElement): boolean;
+export declare function addDynamicLangAttribute(element: t.JSXOpeningElement): void;
+export declare function makeParentFunctionAsync(path: NodePath): boolean;

package/dist/next/jsx/utils.js

@@ -0,0 +1,42 @@
+import * as t from '@babel/types';
+// Helper function to check if is the <html> fragment
+export function isHtmlElement(element) {
+    return (t.isJSXIdentifier(element.name) &&
+        element.name.name.toLowerCase() === 'html');
+}
+// Helper function to check if is the <body> fragment
+export function isBodyElement(element) {
+    return (t.isJSXIdentifier(element.name) &&
+        element.name.name.toLowerCase() === 'body');
+}
+// Helper function to check if the <body> element has a <GTProvider> child
+export function hasGTProviderChild(element) {
+    return element.children.some((child) => t.isJSXElement(child) &&
+        t.isJSXIdentifier(child.openingElement.name) &&
+        child.openingElement.name.name === 'GTProvider');
+}
+export function addDynamicLangAttribute(element) {
+    // Remove existing lang attribute if present
+    const langAttrIndex = element.attributes.findIndex((attr) => t.isJSXAttribute(attr) &&
+        t.isJSXIdentifier(attr.name) &&
+        attr.name.name === 'lang');
+    if (langAttrIndex !== -1) {
+        element.attributes.splice(langAttrIndex, 1);
+    }
+    // Add lang={await getLocale()} attribute
+    element.attributes.push(t.jsxAttribute(t.jsxIdentifier('lang'), t.jsxExpressionContainer(t.awaitExpression(t.callExpression(t.identifier('getLocale'), [])))));
+}
+export function makeParentFunctionAsync(path) {
+    const functionParent = path.getFunctionParent();
+    if (!functionParent)
+        return false;
+    const node = functionParent.node;
+    if ((t.isFunctionDeclaration(node) ||
+        t.isFunctionExpression(node) ||
+        t.isArrowFunctionExpression(node)) &&
+        !node.async) {
+        node.async = true;
+        return true;
+    }
+    return false;
+}

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

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