gt 0.10.0 → 2.7.0

package/dist/fs/config/parseFilesConfig.js

@@ -0,0 +1,150 @@
+import path from 'node:path';
+import fg from 'fast-glob';
+import { SUPPORTED_FILE_EXTENSIONS } from '../../formats/files/supportedFiles.js';
+import { logger } from '../../console/logger.js';
+import chalk from 'chalk';
+import micromatch from 'micromatch';
+/**
+ * Resolves the files from the files object
+ * Replaces [locale] with the actual locale in the files
+ *
+ * @param files - The files object
+ * @param locale - The locale to replace [locale] with
+ * @returns The resolved files
+ */
+export function resolveLocaleFiles(files, locale) {
+    const result = {};
+    for (const fileType of SUPPORTED_FILE_EXTENSIONS) {
+        result[fileType] = files[fileType]?.map((filepath) => filepath.replace(/\[locale\]/g, locale));
+    }
+    // Replace [locale] with locale in all paths
+    result.gt = files.gt?.replace(/\[locale\]/g, locale);
+    return result;
+}
+/**
+ * Resolves the files from the files object
+ * Performs glob pattern expansion on the files
+ * Replaces [locale] with the actual locale in the files
+ *
+ * @param files - The files object
+ * @returns The resolved files
+ */
+export function resolveFiles(files, locale, locales, cwd, compositePatterns) {
+    // Initialize result object with empty arrays for each file type
+    const result = {};
+    const placeholderResult = {};
+    const transformPaths = {};
+    // Process GT files
+    if (files.gt?.output) {
+        placeholderResult.gt = path.resolve(cwd, files.gt.output);
+    }
+    for (const fileType of SUPPORTED_FILE_EXTENSIONS) {
+        // ==== TRANSFORMS ==== //
+        const transform = files[fileType]?.transform;
+        if (transform &&
+            (typeof transform === 'string' ||
+                typeof transform === 'object' ||
+                Array.isArray(transform))) {
+            transformPaths[fileType] = transform;
+        }
+        // ==== PLACEHOLDERS ==== //
+        if (files[fileType]?.include) {
+            const filePaths = expandGlobPatterns(cwd, files[fileType].include, files[fileType]?.exclude || [], locale, locales, transformPaths[fileType] || undefined, compositePatterns);
+            result[fileType] = filePaths.resolvedPaths;
+            placeholderResult[fileType] = filePaths.placeholderPaths;
+        }
+    }
+    return {
+        resolvedPaths: result,
+        placeholderPaths: placeholderResult,
+        transformPaths: transformPaths,
+    };
+}
+// Helper function to expand glob patterns
+export function expandGlobPatterns(cwd, includePatterns, excludePatterns, locale, locales, transformPatterns, compositePatterns) {
+    // Expand glob patterns to include all matching files
+    const resolvedPaths = [];
+    const placeholderPaths = [];
+    // Process include patterns
+    for (const pattern of includePatterns) {
+        // Track positions where [locale] appears in the original pattern
+        // It must be included in the pattern, otherwise the CLI tool will not be able to find the correct output path
+        // Warn if it's not included
+        // Ignore if is composite pattern
+        if (!pattern.includes('[locale]') &&
+            !transformPatterns &&
+            !compositePatterns?.includes(pattern)) {
+            logger.warn(chalk.yellow(`Pattern "${pattern}" does not include [locale], so the CLI tool may incorrectly save translated files.`));
+        }
+        const localePositions = [];
+        let searchIndex = 0;
+        const localeTag = '[locale]';
+        while (true) {
+            const foundIndex = pattern.indexOf(localeTag, searchIndex);
+            if (foundIndex === -1)
+                break;
+            localePositions.push(foundIndex);
+            searchIndex = foundIndex + localeTag.length;
+        }
+        const expandedPattern = pattern.replace(/\[locale\]/g, locale);
+        // Resolve the absolute pattern path
+        const absolutePattern = path.resolve(cwd, expandedPattern);
+        // Prepare exclude patterns with locale replaced
+        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,
+            ignore: expandedExcludePatterns,
+        });
+        resolvedPaths.push(...matches);
+        // For each match, create a version with [locale] in the correct positions
+        matches.forEach((match) => {
+            const absolutePath = path.resolve(cwd, match);
+            const patternPath = path.resolve(cwd, pattern);
+            let originalAbsolutePath = absolutePath;
+            if (localePositions.length > 0) {
+                const placeholderPath = buildPlaceholderPathFromPattern(patternPath, absolutePath, localeTag);
+                originalAbsolutePath = placeholderPath;
+            }
+            placeholderPaths.push(originalAbsolutePath);
+        });
+    }
+    return { resolvedPaths, placeholderPaths };
+}
+function buildPlaceholderPathFromPattern(patternPath, absolutePath, localeTag) {
+    if (!patternPath.includes(localeTag)) {
+        return absolutePath;
+    }
+    const posixPattern = toPosixPath(patternPath);
+    const posixPath = toPosixPath(absolutePath);
+    const baseRegex = micromatch.makeRe(posixPattern, {
+        literalBrackets: true,
+    });
+    const localeRegexSource = baseRegex.source.replace(/\\\[locale\\\]/g, '([^/]+)');
+    const flags = baseRegex.flags.includes('d')
+        ? baseRegex.flags
+        : `${baseRegex.flags}d`;
+    const matcher = new RegExp(localeRegexSource, flags);
+    const match = matcher.exec(posixPath);
+    const matchWithIndices = match;
+    if (!match || !matchWithIndices.indices) {
+        return absolutePath;
+    }
+    let placeholderPosixPath = posixPath;
+    const indices = matchWithIndices.indices;
+    for (let i = indices.length - 1; i >= 1; i--) {
+        const [start, end] = indices[i];
+        if (start === -1 || end === -1)
+            continue;
+        placeholderPosixPath =
+            placeholderPosixPath.slice(0, start) +
+                localeTag +
+                placeholderPosixPath.slice(end);
+    }
+    return path.normalize(placeholderPosixPath);
+}
+function toPosixPath(value) {
+    return value.split(path.sep).join(path.posix.sep);
+}

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

@@ -0,0 +1,17 @@
+import { FilesOptions, SupportedFrameworks } from '../../types/index.js';
+/**
+ * Checks if the config file exists.
+ * If yes, make sure make sure projectId is correct
+ * If not, creates a new JSON file at the given filepath and writes the provided config object to it.
+ * @param {string} configFilepath - The path to the config file.
+ * @param {Record<string, any>} configObject - The config object to write if the file does not exist.
+ */
+export declare function createOrUpdateConfig(configFilepath: string, options: {
+    projectId?: string;
+    defaultLocale?: string;
+    locales?: string[];
+    files?: FilesOptions;
+    framework?: SupportedFrameworks;
+    baseUrl?: string;
+    publish?: boolean;
+}): Promise<string>;

package/dist/fs/config/setupConfig.js

@@ -0,0 +1,50 @@
+import fs from 'node:fs';
+import { displayCreatedConfigFile } from '../../console/logging.js';
+import { logger } from '../../console/logger.js';
+import { GT_CONFIG_SCHEMA_URL } from '../../utils/constants.js';
+/**
+ * Checks if the config file exists.
+ * If yes, make sure make sure projectId is correct
+ * If not, creates a new JSON file at the given filepath and writes the provided config object to it.
+ * @param {string} configFilepath - The path to the config file.
+ * @param {Record<string, any>} configObject - The config object to write if the file does not exist.
+ */
+export async function createOrUpdateConfig(configFilepath, options) {
+    // Filter out empty string values from the config object
+    const newContent = {
+        ...(options.projectId && { projectId: options.projectId }),
+        ...(options.defaultLocale && { defaultLocale: options.defaultLocale }),
+        ...(options.files && { files: options.files }),
+        ...(options.framework && { framework: options.framework }),
+        ...(options.baseUrl && { baseUrl: options.baseUrl }),
+        ...(options.publish && { publish: options.publish }),
+    };
+    try {
+        // if file exists
+        let oldContent = {};
+        if (fs.existsSync(configFilepath)) {
+            oldContent = JSON.parse(await fs.promises.readFile(configFilepath, 'utf-8'));
+        }
+        // merge old and new content
+        const mergedContent = {
+            $schema: GT_CONFIG_SCHEMA_URL,
+            ...oldContent,
+            ...newContent,
+        };
+        // Add locales to mergedContent if they exist
+        if (options.locales) {
+            mergedContent.locales = mergedContent.locales
+                ? [...new Set([...mergedContent.locales, ...options.locales])]
+                : options.locales;
+        }
+        // write to file
+        const mergedJsonContent = JSON.stringify(mergedContent, null, 2);
+        await fs.promises.writeFile(configFilepath, mergedJsonContent, 'utf-8');
+        // show update in console
+        displayCreatedConfigFile(configFilepath);
+    }
+    catch (error) {
+        logger.error(`An error occurred while updating ${configFilepath}: ${error}`);
+    }
+    return configFilepath;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Options for updating the config file.
+ *
+ * Since these are all string values, we can use null to mark them for removal
+ */
+type UpdateConfigOptions = {
+    projectId?: string | null;
+    _versionId?: string | null;
+    _branchId?: string | null;
+    stageTranslations?: boolean | null;
+};
+/**
+ * Update the config file version id, locales, and projectId (if necessary)
+ * @param {string} configFilepath - The path to the config file.
+ * @param {UpdateConfigOptions} options - The options to update the config file with.
+ * @returns {Promise<void>} - A promise that resolves when the config file is updated.
+ *
+ * Hint: Mark a field as null to remove it from the config file.
+ */
+export default function updateConfig(configFilepath: string, options: UpdateConfigOptions): Promise<void>;
+export {};

package/dist/fs/config/updateConfig.js

@@ -0,0 +1,57 @@
+import fs from 'node:fs';
+import { displayUpdatedConfigFile } from '../../console/logging.js';
+import { logger } from '../../console/logger.js';
+/**
+ * Update the config file version id, locales, and projectId (if necessary)
+ * @param {string} configFilepath - The path to the config file.
+ * @param {UpdateConfigOptions} options - The options to update the config file with.
+ * @returns {Promise<void>} - A promise that resolves when the config file is updated.
+ *
+ * Hint: Mark a field as null to remove it from the config file.
+ */
+export default async function updateConfig(configFilepath, options) {
+    // Filter out empty string values from the config object
+    const { projectId, _versionId, _branchId, stageTranslations } = options;
+    const newContent = {
+        ...(projectId && { projectId }),
+        ...(_versionId && { _versionId }),
+        ...(_branchId && { _branchId }),
+        // Omit when false
+        ...(stageTranslations && { stageTranslations }),
+    };
+    try {
+        // if file exists
+        let oldContent = {};
+        if (fs.existsSync(configFilepath)) {
+            oldContent = JSON.parse(await fs.promises.readFile(configFilepath, 'utf-8'));
+        }
+        // merge old and new content
+        const mergedContent = {
+            ...oldContent,
+            ...newContent,
+        };
+        // Apply null filter to remove values that were marked for removal
+        const filteredContent = applyNullFilter(mergedContent, options);
+        // write to file
+        const jsonContent = JSON.stringify(filteredContent, null, 2);
+        await fs.promises.writeFile(configFilepath, jsonContent, 'utf-8');
+        // show update in console
+        displayUpdatedConfigFile(configFilepath);
+    }
+    catch (error) {
+        logger.error(`An error occurred while updating ${configFilepath}: ${error}`);
+    }
+}
+// --- Helper functions --- //
+/**
+ * Remove values from object if they were marked for removal
+ */
+function applyNullFilter(obj, filter) {
+    const result = { ...obj };
+    for (const key of Object.keys(filter)) {
+        if (filter[key] === null) {
+            delete result[key];
+        }
+    }
+    return result;
+}

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

@@ -0,0 +1,11 @@
+type StagedVersionData = Record<string, // fileId
+{
+    fileName: string;
+    versionId: string;
+}>;
+export declare function updateVersions({ configDirectory, versionData, }: {
+    configDirectory: string;
+    versionData: StagedVersionData;
+}): Promise<void>;
+export declare function getStagedVersions(configDirectory: string): Promise<StagedVersionData>;
+export {};

package/dist/fs/config/updateVersions.js

@@ -0,0 +1,30 @@
+import fs from 'node:fs';
+import { displayUpdatedVersionsFile } from '../../console/logging.js';
+import { logger } from '../../console/logger.js';
+import path from 'node:path';
+const STAGED_VERSIONS_FILE = 'staged-versions.json';
+// Update the versions.json file with the new version ids
+// of the translations that were sent to the API
+export async function updateVersions({ configDirectory, versionData, }) {
+    const versionFilepath = path.join(configDirectory, STAGED_VERSIONS_FILE);
+    try {
+        fs.mkdirSync(configDirectory, { recursive: true });
+        fs.writeFileSync(versionFilepath, JSON.stringify(versionData, null, 2));
+        // show update in console
+        displayUpdatedVersionsFile(versionFilepath);
+    }
+    catch (error) {
+        logger.error(`An error occurred while updating ${versionFilepath}: ${error}`);
+    }
+}
+export async function getStagedVersions(configDirectory) {
+    try {
+        const versionFilepath = path.join(configDirectory, STAGED_VERSIONS_FILE);
+        const versionData = JSON.parse(fs.readFileSync(versionFilepath, 'utf8'));
+        return versionData;
+    }
+    catch (error) {
+        logger.error(`An error occurred while getting staged versions: ${error}`);
+        return {};
+    }
+}

package/dist/fs/copyFile.d.ts

@@ -0,0 +1,7 @@
+import { Settings } from '../types/index.js';
+/**
+ * Copy a file to target locale without translation
+ *
+ * This is a naive approach, does not allow for wild cards
+ */
+export default function copyFile(settings: Settings): Promise<void>;

package/dist/fs/copyFile.js

@@ -0,0 +1,39 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { logger } from '../console/logger.js';
+/**
+ * Copy a file to target locale without translation
+ *
+ * This is a naive approach, does not allow for wild cards
+ */
+export default async function copyFile(settings) {
+    if (!settings.options?.copyFiles || settings.options.copyFiles.length === 0) {
+        return;
+    }
+    // Construct a map of source paths to target paths
+    const copyFiles = settings.options.copyFiles.reduce((paths, filePathTemplate) => {
+        const sourcePath = path.join(process.cwd(), filePathTemplate.replace('[locale]', settings.defaultLocale));
+        if (!fs.existsSync(sourcePath)) {
+            logger.error(`Failed to copy files: File path does not exist: ${sourcePath}`);
+            return paths;
+        }
+        paths[sourcePath] = [];
+        for (const locale of settings.locales) {
+            if (locale === settings.defaultLocale)
+                continue;
+            const targetPath = path.join(process.cwd(), filePathTemplate.replace('[locale]', locale));
+            paths[sourcePath].push(targetPath);
+        }
+        return paths;
+    }, {});
+    // Copy each file to the target locale
+    for (const sourcePath in copyFiles) {
+        for (const targetPath of copyFiles[sourcePath]) {
+            // Ensure the target directory exists
+            const targetDir = path.dirname(targetPath);
+            await fs.promises.mkdir(targetDir, { recursive: true });
+            // Copy the file
+            await fs.promises.copyFile(sourcePath, targetPath);
+        }
+    }
+}

package/dist/fs/createLoadTranslationsFile.d.ts

@@ -0,0 +1 @@
+export declare function createLoadTranslationsFile(appDirectory: string, translationsDir: string | undefined, locales: string[]): Promise<void>;

package/dist/fs/createLoadTranslationsFile.js

@@ -0,0 +1,49 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { logger } from '../console/logger.js';
+import chalk from 'chalk';
+export async function createLoadTranslationsFile(appDirectory, translationsDir = './public/_gt', locales) {
+    const usingSrcDirectory = fs.existsSync(path.join(appDirectory, 'src'));
+    // Calculate the relative path from the loadTranslations.js location to the translations directory
+    const loadTranslationsDir = usingSrcDirectory
+        ? path.join(appDirectory, 'src')
+        : appDirectory;
+    const relativePath = path.relative(loadTranslationsDir, path.resolve(appDirectory, translationsDir));
+    const publicPath = relativePath ? `${relativePath}/` : './';
+    const filePath = usingSrcDirectory
+        ? path.join(appDirectory, 'src', 'loadTranslations.js')
+        : path.join(appDirectory, 'loadTranslations.js');
+    if (!fs.existsSync(filePath)) {
+        const loadTranslationsContent = `
+export default async function loadTranslations(locale) {
+  try {
+    // Load translations from ${translationsDir} directory
+    // This matches the GT config files.gt.output path
+    const t = await import(\`${publicPath}\${locale}.json\`);
+    return t.default;
+  } catch (error) {
+    console.warn(\`Failed to load translations for locale \${locale}:\`, error);
+    return {};
+  }
+}
+`;
+        await fs.promises.writeFile(filePath, loadTranslationsContent);
+        logger.info(`Created ${chalk.cyan('loadTranslations.js')} file at ${chalk.cyan(filePath)}.`);
+        try {
+            await fs.promises.mkdir(translationsDir, { recursive: true });
+            // Create empty JSON files
+            for (const locale of locales) {
+                if (fs.existsSync(path.join(translationsDir, `${locale}.json`))) {
+                    continue;
+                }
+                await fs.promises.writeFile(path.join(translationsDir, `${locale}.json`), '{}');
+            }
+        }
+        catch (error) {
+            logger.error(`Failed to create translations directory: ${error}`);
+        }
+    }
+    else {
+        logger.info(`Found ${chalk.cyan('loadTranslations.js')} file at ${chalk.cyan(filePath)}. Skipping creation...`);
+    }
+}

package/dist/fs/determineFramework.d.ts

@@ -0,0 +1,5 @@
+import { SupportedLibraries } from '../types/index.js';
+export declare function determineLibrary(): {
+    library: SupportedLibraries;
+    additionalModules: SupportedLibraries[];
+};

package/dist/fs/determineFramework.js

@@ -0,0 +1,53 @@
+import chalk from 'chalk';
+import path from 'node:path';
+import fs from 'node:fs';
+import { logger } from '../console/logger.js';
+import { Libraries } from '../types/libraries.js';
+export function determineLibrary() {
+    let library = 'base';
+    const additionalModules = [];
+    try {
+        // Get the current working directory (where the CLI is being run)
+        const cwd = process.cwd();
+        const packageJsonPath = path.join(cwd, 'package.json');
+        // Check if package.json exists
+        if (!fs.existsSync(packageJsonPath)) {
+            logger.warn(chalk.yellow('No package.json found in the current directory. Please run this command from the root of your project.'));
+            return { library: 'base', additionalModules: [] };
+        }
+        // Read and parse package.json
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        const dependencies = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+        };
+        // Check for gt-next or gt-react in dependencies
+        if (dependencies[Libraries.GT_NEXT]) {
+            library = Libraries.GT_NEXT;
+        }
+        else if (dependencies[Libraries.GT_REACT]) {
+            library = Libraries.GT_REACT;
+        }
+        else if (dependencies[Libraries.GT_REACT_NATIVE]) {
+            library = Libraries.GT_REACT_NATIVE;
+        }
+        else if (dependencies[Libraries.GT_NODE]) {
+            library = Libraries.GT_NODE;
+        }
+        else if (dependencies['next-intl']) {
+            library = 'next-intl';
+        }
+        else if (dependencies['i18next']) {
+            library = 'i18next';
+        }
+        if (dependencies['i18next-icu']) {
+            additionalModules.push('i18next-icu');
+        }
+        // Fallback to base if neither is found
+        return { library, additionalModules };
+    }
+    catch (error) {
+        logger.error('Error determining framework: ' + String(error));
+        return { library: 'base', additionalModules: [] };
+    }
+}

package/dist/fs/findFilepath.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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: string[], errorMessage?: string): string;
+/**
+ * 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 declare function findFilepaths(paths: string[], errorMessage?: string): string[];
+export declare function getRelativePath(file: string, srcDirectory: string): string;
+/**
+ * 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 declare function findFile(filePattern: string, file: string): string;
+/**
+ * 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 declare function readFile(filePath: string): string;
+/**
+ * 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 declare function findFileInDir(dir: string, file: string): string;
+export declare function getRelative(absolutePath: string): string;

package/dist/fs/findFilepath.js

@@ -0,0 +1,90 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { logger } from '../console/logger.js';
+import { exitSync } 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) {
+        logger.error(errorMessage);
+        exitSync(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) {
+        logger.error('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/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[];