gtx-cli 2.3.5 → 2.3.6-alpha.2

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

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

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

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

package/dist/formats/yaml/parseYaml.js

@@ -1,23 +0,0 @@
-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, fileFormat: 'YAML' };
-    }
-    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 { content: JSON.stringify(flattenedYaml), fileFormat: 'JSON' };
-    }
-    return { content, fileFormat: 'YAML' };
-}

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

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

package/dist/formats/yaml/utils.js

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

@@ -1 +0,0 @@
-export declare function loadConfig(filepath: string): Record<string, any>;

package/dist/fs/config/loadConfig.js

@@ -1,9 +0,0 @@
-import fs from 'node:fs';
-export function loadConfig(filepath) {
-    try {
-        return JSON.parse(fs.readFileSync(filepath, 'utf-8'));
-    }
-    catch (error) {
-        return {};
-    }
-}

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

@@ -1,27 +0,0 @@
-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
- *
- * @param files - The files object
- * @param locale - The locale to replace [locale] with
- * @returns The resolved files
- */
-export declare function resolveLocaleFiles(files: ResolvedFiles, locale: string): ResolvedFiles;
-/**
- * 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 declare function resolveFiles(files: FilesOptions, locale: string, locales: string[], cwd: string, compositePatterns?: string[]): {
-    resolvedPaths: ResolvedFiles;
-    placeholderPaths: ResolvedFiles;
-    transformPaths: TransformFiles;
-};
-export declare function expandGlobPatterns(cwd: string, includePatterns: string[], excludePatterns: string[], locale: string, locales: string[], transformPatterns?: TransformOption | string, compositePatterns?: string[]): {
-    resolvedPaths: string[];
-    placeholderPaths: string[];
-};

package/dist/fs/config/parseFilesConfig.js

@@ -1,129 +0,0 @@
-import path from 'node:path';
-import fg from 'fast-glob';
-import { SUPPORTED_FILE_EXTENSIONS } from '../../formats/files/supportedFiles.js';
-import { logWarning } from '../../console/logging.js';
-import chalk from 'chalk';
-/**
- * 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 &&
-            !Array.isArray(transform) &&
-            (typeof transform === 'string' || typeof transform === 'object')) {
-            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)) {
-            logWarning(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) => {
-            // Convert to absolute path to make replacement easier
-            const absolutePath = path.resolve(cwd, match);
-            const patternPath = path.resolve(cwd, pattern);
-            let originalAbsolutePath = absolutePath;
-            if (localePositions.length > 0) {
-                // Replace all instances of [locale]
-                // but only in path segments where we expect it based on the original pattern
-                const pathParts = absolutePath.split(path.sep);
-                const patternParts = patternPath.split(path.sep);
-                for (let i = 0; i < pathParts.length; i++) {
-                    if (i < patternParts.length) {
-                        if (patternParts[i].includes(localeTag)) {
-                            // This segment should have the locale replaced
-                            // Create regex from pattern to match the actual path structure
-                            const regexPattern = patternParts[i].replace(/\[locale\]/g, `(${locale.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})`);
-                            const regex = new RegExp(regexPattern);
-                            pathParts[i] = pathParts[i].replace(regex, patternParts[i].replace(/\[locale\]/g, localeTag));
-                        }
-                    }
-                }
-                originalAbsolutePath = pathParts.join(path.sep);
-            }
-            // Convert back to absolute path
-            placeholderPaths.push(originalAbsolutePath);
-        });
-    }
-    return { resolvedPaths, placeholderPaths };
-}

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

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

@@ -1,50 +0,0 @@
-import fs from 'node:fs';
-import { displayCreatedConfigFile } from '../../console/logging.js';
-import { logError } from '../../console/logging.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) {
-        logError(`An error occurred while updating ${configFilepath}: ${error}`);
-    }
-    return configFilepath;
-}

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

@@ -1,10 +0,0 @@
-/**
- * Update the config file version id, locales, and projectId (if necessary)
- * @param {Record<string, any>} configObject - The config object to write if the file does not exist.
- */
-export default function updateConfig({ configFilepath, projectId, _versionId, stageTranslations, }: {
-    configFilepath: string;
-    projectId?: string;
-    _versionId?: string;
-    stageTranslations?: boolean;
-}): Promise<void>;

package/dist/fs/config/updateConfig.js

@@ -1,36 +0,0 @@
-import fs from 'node:fs';
-import { displayUpdatedConfigFile } from '../../console/logging.js';
-import { logError } from '../../console/logging.js';
-/**
- * Update the config file version id, locales, and projectId (if necessary)
- * @param {Record<string, any>} configObject - The config object to write if the file does not exist.
- */
-export default async function updateConfig({ configFilepath, projectId, _versionId, stageTranslations, }) {
-    // Filter out empty string values from the config object
-    const newContent = {
-        ...(projectId && { projectId }),
-        ...(_versionId && { _versionId }),
-        ...(stageTranslations && { stageTranslations }),
-        // ...(locales && { locales }), // Don't override locales
-    };
-    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,
-        };
-        // write to file
-        const mergedJsonContent = JSON.stringify(mergedContent, null, 2);
-        await fs.promises.writeFile(configFilepath, mergedJsonContent, 'utf-8');
-        // show update in console
-        displayUpdatedConfigFile(configFilepath);
-    }
-    catch (error) {
-        logError(`An error occurred while updating ${configFilepath}: ${error}`);
-    }
-}

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

@@ -1,10 +0,0 @@
-type StagedVersionData = Record<string, {
-    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

@@ -1,30 +0,0 @@
-import fs from 'node:fs';
-import { displayUpdatedVersionsFile } from '../../console/logging.js';
-import { logError } from '../../console/logging.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) {
-        logError(`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) {
-        logError(`An error occurred while getting staged versions: ${error}`);
-        return {};
-    }
-}

package/dist/fs/copyFile.d.ts

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

@@ -1,39 +0,0 @@
-import path from 'node:path';
-import fs from 'node:fs';
-import { logError } from '../console/logging.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)) {
-            logError(`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

@@ -1 +0,0 @@
-export declare function createLoadTranslationsFile(appDirectory: string, translationsDir?: string): Promise<void>;

package/dist/fs/createLoadTranslationsFile.js

@@ -1,36 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { logInfo } from '../console/logging.js';
-import chalk from 'chalk';
-export async function createLoadTranslationsFile(appDirectory, translationsDir = './public/_gt') {
-    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);
-        logInfo(`Created ${chalk.cyan('loadTranslations.js')} file at ${chalk.cyan(filePath)}.`);
-    }
-    else {
-        logInfo(`Found ${chalk.cyan('loadTranslations.js')} file at ${chalk.cyan(filePath)}. Skipping creation...`);
-    }
-}

package/dist/fs/determineFramework.d.ts

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

package/dist/fs/determineFramework.js

@@ -1,46 +0,0 @@
-import chalk from 'chalk';
-import path from 'node:path';
-import fs from 'node:fs';
-import { logError } from '../console/logging.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)) {
-            logError(chalk.red('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['gt-next']) {
-            library = 'gt-next';
-        }
-        else if (dependencies['gt-react']) {
-            library = 'gt-react';
-        }
-        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) {
-        logError('Error determining framework: ' + String(error));
-        return { library: 'base', additionalModules: [] };
-    }
-}

package/dist/fs/findFilepath.d.ts

@@ -1,36 +0,0 @@
-/**
- * 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;