gtx-cli 2.3.4 → 2.3.6-alpha.1

package/dist/formats/json/utils.js

@@ -1,149 +0,0 @@
-import { getLocaleProperties } from 'generaltranslation';
-import { exit, logError } from '../../console/logging.js';
-import { JSONPath } from 'jsonpath-plus';
-import { flattenJson } from './flattenJson.js';
-import path from 'node:path';
-import micromatch from 'micromatch';
-const { isMatch } = micromatch;
-// Find the matching source item in an array
-// where the key matches the identifying locale property
-// If no matching item is found, exit with an error
-export function findMatchingItemArray(locale, sourceObjectOptions, sourceObjectPointer, sourceObjectValue) {
-    const { identifyingLocaleProperty, localeKeyJsonPath } = getSourceObjectOptionsArray(locale, sourceObjectPointer, sourceObjectOptions);
-    // Use the json pointer key to locate the source item
-    const matchingItems = {};
-    for (const [index, item] of sourceObjectValue.entries()) {
-        // Get the key candidates
-        const keyCandidates = JSONPath({
-            json: item,
-            path: localeKeyJsonPath,
-            resultType: 'all',
-            flatten: true,
-            wrap: true,
-        });
-        if (!keyCandidates) {
-            logError(`Source item at path: ${sourceObjectPointer} does not have a key value at path: ${localeKeyJsonPath}`);
-            exit(1);
-        }
-        else if (keyCandidates.length === 0) {
-            // If no key candidates, skip the item
-            continue;
-        }
-        else if (keyCandidates.length > 1) {
-            // If multiple key candidates, exit with an error
-            logError(`Source item at path: ${sourceObjectPointer} has multiple matching keys with path: ${localeKeyJsonPath}`);
-            exit(1);
-        }
-        else if (identifyingLocaleProperty !== keyCandidates[0].value) {
-            // Validate the key is the identifying locale property
-            continue;
-        }
-        // Map the index to the source item
-        matchingItems[`/${index}`] = {
-            sourceItem: item,
-            keyParentProperty: keyCandidates[0].parentProperty,
-            keyPointer: keyCandidates[0].pointer,
-            index,
-        };
-    }
-    return matchingItems;
-}
-export function findMatchingItemObject(locale, sourceObjectPointer, sourceObjectOptions, sourceObjectValue) {
-    const { identifyingLocaleProperty } = getSourceObjectOptionsObject(locale, sourceObjectPointer, sourceObjectOptions);
-    // Locate the source item
-    if (sourceObjectValue[identifyingLocaleProperty]) {
-        return {
-            sourceItem: sourceObjectValue[identifyingLocaleProperty],
-            keyParentProperty: identifyingLocaleProperty,
-        };
-    }
-    return {
-        sourceItem: undefined,
-        keyParentProperty: identifyingLocaleProperty,
-    };
-}
-/**
- * Get the identifying locale property for an object
- * @param locale - The locale to get the identifying locale property for
- * @param sourceObjectPointer - The path to the source object
- * @param sourceObjectOptions - The source object options
- * @returns The identifying locale property
- */
-export function getIdentifyingLocaleProperty(locale, sourceObjectPointer, sourceObjectOptions) {
-    // Validate localeProperty
-    const localeProperty = sourceObjectOptions.localeProperty || 'code';
-    const identifyingLocaleProperty = getLocaleProperties(locale)[localeProperty];
-    if (!identifyingLocaleProperty) {
-        logError(`Source object options localeProperty is not a valid locale property at path: ${sourceObjectPointer}`);
-        exit(1);
-    }
-    return identifyingLocaleProperty;
-}
-/**
- * Get the identifying locale property and the json path to the key for an array
- * @param locale - The locale to get the identifying locale property for
- * @param sourceObjectPointer - The path to the source object
- * @param sourceObjectOptions - The source object options
- * @returns The identifying locale property and the json path to the key
- */
-export function getSourceObjectOptionsArray(locale, sourceObjectPointer, sourceObjectOptions) {
-    const identifyingLocaleProperty = getIdentifyingLocaleProperty(locale, sourceObjectPointer, sourceObjectOptions);
-    const localeKeyJsonPath = sourceObjectOptions.key;
-    if (!localeKeyJsonPath) {
-        logError(`Source object options key is required for array at path: ${sourceObjectPointer}`);
-        exit(1);
-    }
-    return { identifyingLocaleProperty, localeKeyJsonPath };
-}
-export function getSourceObjectOptionsObject(defaultLocale, sourceObjectPointer, sourceObjectOptions) {
-    const identifyingLocaleProperty = getIdentifyingLocaleProperty(defaultLocale, sourceObjectPointer, sourceObjectOptions);
-    const jsonPathKey = sourceObjectOptions.key;
-    if (jsonPathKey) {
-        logError(`Source object options key is not allowed for object at path: ${sourceObjectPointer}`);
-        exit(1);
-    }
-    return { identifyingLocaleProperty };
-}
-/**
- * Generate a mapping of sourceObjectPointer to SourceObjectOptions
- * where the sourceObjectPointer is a jsonpointer to the array or object containing
- * @param jsonSchema - The json schema to generate the mapping from
- * @param originalJson - The original json to generate the mapping from
- * @returns A mapping of sourceObjectPointer to SourceObjectOptions
- */
-export function generateSourceObjectPointers(jsonSchema, originalJson) {
-    const sourceObjectPointers = Object.entries(jsonSchema).reduce((acc, [sourceObjectPath, sourceObjectOptions]) => {
-        const sourceObjects = flattenJson(originalJson, [sourceObjectPath]);
-        Object.entries(sourceObjects).forEach(([pointer, value]) => {
-            acc[pointer] = {
-                sourceObjectValue: value,
-                sourceObjectOptions,
-            };
-        });
-        return acc;
-    }, {});
-    return sourceObjectPointers;
-}
-export function validateJsonSchema(options, filePath) {
-    if (!options.jsonSchema) {
-        return null;
-    }
-    const fileGlobs = Object.keys(options.jsonSchema);
-    const matchingGlob = fileGlobs.find((fileGlob) => isMatch(path.relative(process.cwd(), filePath), fileGlob));
-    if (!matchingGlob || !options.jsonSchema[matchingGlob]) {
-        return null;
-    }
-    // Validate includes or composite
-    const jsonSchema = options.jsonSchema[matchingGlob];
-    if (jsonSchema.include && jsonSchema.composite) {
-        logError('include and composite cannot be used together in the same JSON schema');
-        exit(1);
-        return null;
-    }
-    if (!jsonSchema.include && !jsonSchema.composite) {
-        logError('No include or composite property found in JSON schema');
-        exit(1);
-        return null;
-    }
-    return jsonSchema;
-}

package/dist/formats/utils.d.ts

@@ -1,2 +0,0 @@
-import { LocaleProperties } from 'generaltranslation/types';
-export declare function replaceLocalePlaceholders(string: string, localeProperties: LocaleProperties): string;

package/dist/formats/utils.js

@@ -1,24 +0,0 @@
-// helper function to replace locale placeholders in a string
-// with the corresponding locale properties
-// ex: {locale} -> will be replaced with the locale code
-// ex: {localeName} -> will be replaced with the locale name
-export function replaceLocalePlaceholders(string, localeProperties) {
-    return string.replace(/\{(\w+)\}/g, (match, property) => {
-        // Handle common aliases
-        if (property === 'locale' || property === 'localeCode') {
-            return localeProperties.code;
-        }
-        if (property === 'localeName') {
-            return localeProperties.name;
-        }
-        if (property === 'localeNativeName') {
-            return localeProperties.nativeName;
-        }
-        // Check if the property exists in localeProperties
-        if (property in localeProperties) {
-            return localeProperties[property];
-        }
-        // Return the original placeholder if property not found
-        return match;
-    });
-}

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): {
-    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

@@ -1,126 +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) {
-    // 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);
-            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) {
-    // 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
-        if (!pattern.includes('[locale]') && !transformPatterns) {
-            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>;