gtx-cli 2.6.31 → 2.7.0

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;
-}[], defaultLocale: string): string[];

package/dist/formats/yaml/mergeYaml.js

@@ -1,61 +0,0 @@
-import JSONPointer from 'jsonpointer';
-import { exitSync } from '../../console/logging.js';
-import { logger } from '../../console/logger.js';
-import { validateYamlSchema } from './utils.js';
-import YAML from 'yaml';
-import { applyTransformations } from '../json/mergeJson.js';
-export default function mergeYaml(originalContent, inputPath, options, targets, defaultLocale) {
-    const yamlSchema = validateYamlSchema(options, inputPath);
-    if (!yamlSchema) {
-        return targets.map((target) => target.translatedContent);
-    }
-    let originalYaml;
-    try {
-        originalYaml = YAML.parse(originalContent);
-    }
-    catch {
-        logger.error(`Invalid YAML file: ${inputPath}`);
-        return exitSync(1);
-    }
-    // Unreachable (validated in validateYamlSchema, included for type check)
-    if (!yamlSchema.include) {
-        logger.error('No include property found in YAML schema');
-        return exitSync(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
-            }
-        }
-        // Apply transformations if they exist
-        if (yamlSchema.transform) {
-            applyTransformations(mergedYaml, yamlSchema.transform, target.targetLocale, defaultLocale);
-        }
-        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,24 +0,0 @@
-import { exitSync } from '../../console/logging.js';
-import { logger } from '../../console/logger.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 {
-        logger.error(`Invalid YAML file: ${filePath}`);
-        return exitSync(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,23 +0,0 @@
-import { exitSync } from '../../console/logging.js';
-import { logger } from '../../console/logger.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) {
-        logger.error('No include property found in YAML schema');
-        return exitSync(1);
-    }
-    return yamlSchema;
-}

package/dist/fs/clearLocaleDirs.d.ts

@@ -1,8 +0,0 @@
-/**
- * Clears translated files before writing new translations
- * @param filePaths - Set of translated file paths to clear
- * @param locales - Array of locale codes to match against
- * @param excludePatterns - Optional array of glob patterns to exclude from clearing (supports [locale] and [locales])
- * @param cwd - Current working directory for resolving relative exclude patterns (defaults to process.cwd())
- */
-export declare function clearLocaleDirs(filePaths: Set<string>, locales: string[], excludePatterns?: string[], cwd?: string): Promise<void>;

package/dist/fs/clearLocaleDirs.js

@@ -1,126 +0,0 @@
-import fs from 'fs/promises';
-import path from 'node:path';
-import { logger } from '../console/logger.js';
-import fg from 'fast-glob';
-import micromatch from 'micromatch';
-/**
- * Extracts locale directories from translated file paths.
- * Groups files by their immediate parent containing a locale code.
- * For example: "snippets/es/api-test/file.mdx" -> "snippets/es"
- */
-function extractLocaleDirectories(filePaths, locales) {
-    const localeDirs = new Set();
-    const localeSet = new Set(locales);
-    for (const filePath of filePaths) {
-        const parts = filePath.split(path.sep);
-        // Find directory segments that match the provided locales
-        for (let i = 0; i < parts.length - 1; i++) {
-            const segment = parts[i];
-            if (localeSet.has(segment)) {
-                // Found a locale directory, capture up to and including this segment
-                const localeDir = parts.slice(0, i + 1).join(path.sep);
-                localeDirs.add(localeDir);
-                break;
-            }
-        }
-    }
-    return localeDirs;
-}
-async function getAllFiles(dirPath) {
-    return await fg(path.join(dirPath, '**/*'), {
-        absolute: true,
-        onlyFiles: true,
-    });
-}
-async function getFilesToDelete(dirPath, excludePatterns, currentLocale, cwd) {
-    const allFiles = await getAllFiles(dirPath);
-    const absoluteCwd = path.resolve(cwd);
-    const expandedExcludePatterns = excludePatterns.map((p) => {
-        const resolvedPattern = path.isAbsolute(p) ? p : path.join(absoluteCwd, p);
-        return resolvedPattern
-            .replace(/\[locale\]/g, currentLocale)
-            .replace(/\[locales\]/g, currentLocale);
-    });
-    const filesToKeep = micromatch(allFiles, expandedExcludePatterns, {
-        dot: true,
-    });
-    const filesToKeepSet = new Set(filesToKeep);
-    return allFiles.filter((file) => !filesToKeepSet.has(file));
-}
-/**
- * Clears translated files before writing new translations
- * @param filePaths - Set of translated file paths to clear
- * @param locales - Array of locale codes to match against
- * @param excludePatterns - Optional array of glob patterns to exclude from clearing (supports [locale] and [locales])
- * @param cwd - Current working directory for resolving relative exclude patterns (defaults to process.cwd())
- */
-export async function clearLocaleDirs(filePaths, locales, excludePatterns, cwd = process.cwd()) {
-    // Extract locale directories
-    const localeDirs = extractLocaleDirectories(filePaths, locales);
-    for (const dir of localeDirs) {
-        try {
-            await fs.stat(dir);
-            // Extract locale from directory path
-            const dirParts = dir.split(path.sep);
-            const locale = locales.find((loc) => dirParts.includes(loc));
-            if (!locale) {
-                continue;
-            }
-            if (!excludePatterns?.length) {
-                await fs.rm(dir, { recursive: true, force: true });
-                logger.success(`Cleared locale directory: ${dir}`);
-                continue;
-            }
-            const filesToDelete = await getFilesToDelete(dir, excludePatterns, locale, cwd);
-            // Get all files for count comparison
-            const allFiles = await getAllFiles(dir);
-            for (const file of filesToDelete) {
-                try {
-                    await fs.unlink(file);
-                }
-                catch (error) {
-                    if (error.code !== 'ENOENT') {
-                        logger.warn(`Failed to delete file ${file}: ${error}`);
-                    }
-                }
-            }
-            // Clean up empty directories
-            await cleanupEmptyDirs(dir);
-            const excludedCount = allFiles.length - filesToDelete.length;
-            if (excludedCount > 0) {
-                logger.success(`Cleared locale directory: ${dir} (excluded ${excludedCount} file${excludedCount > 1 ? 's' : ''})`);
-            }
-            else {
-                logger.success(`Cleared locale directory: ${dir}`);
-            }
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT') {
-                logger.warn(`Failed to clear locale directory ${dir}: ${error}`);
-            }
-        }
-    }
-}
-/**
- * Recursively removes empty directories
- * @param dirPath - The directory to clean up
- */
-async function cleanupEmptyDirs(dirPath) {
-    try {
-        const entries = await fs.readdir(dirPath, { withFileTypes: true });
-        // Recursively clean subdirectories first
-        for (const entry of entries) {
-            if (entry.isDirectory()) {
-                await cleanupEmptyDirs(path.join(dirPath, entry.name));
-            }
-        }
-        // Check if directory is now empty
-        const remainingEntries = await fs.readdir(dirPath);
-        if (remainingEntries.length === 0) {
-            await fs.rmdir(dirPath);
-        }
-    }
-    catch (error) {
-        // Ignore errors - directory might not exist or might not be empty
-    }
-}

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

@@ -1,21 +0,0 @@
-export type DownloadedVersionEntry = {
-    fileName?: string;
-    updatedAt?: string;
-    postProcessHash?: string;
-    sourceHash?: string;
-};
-export type DownloadedVersions = {
-    version: number;
-    entries: {
-        [branchId: string]: {
-            [fileId: string]: {
-                [versionId: string]: {
-                    [locale: string]: DownloadedVersionEntry;
-                };
-            };
-        };
-    };
-};
-export declare function getDownloadedVersions(configDirectory: string): DownloadedVersions;
-export declare function saveDownloadedVersions(configDirectory: string, lock: DownloadedVersions): void;
-export declare function ensureNestedObject(obj: any, path: string[]): any;

package/dist/fs/config/downloadedVersions.js

@@ -1,50 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { logger } from '../../console/logger.js';
-// New lock file name, use old name for deletion of legacy lock file
-const GT_LOCK_FILE = 'gt-lock.json';
-const LEGACY_DOWNLOADED_VERSIONS_FILE = 'downloaded-versions.json';
-export function getDownloadedVersions(configDirectory) {
-    try {
-        // Clean up legacy lock files inside the config directory
-        const rootPath = path.join(process.cwd(), GT_LOCK_FILE);
-        const legacyPath = path.join(configDirectory, LEGACY_DOWNLOADED_VERSIONS_FILE);
-        try {
-            if (fs.existsSync(legacyPath)) {
-                fs.unlinkSync(legacyPath);
-            }
-        }
-        catch { }
-        const filepath = fs.existsSync(rootPath) ? rootPath : null;
-        if (!filepath)
-            return { version: 1, entries: {} };
-        const raw = JSON.parse(fs.readFileSync(filepath, 'utf8'));
-        if (raw && typeof raw === 'object' && raw.version && raw.entries) {
-            return raw;
-        }
-        return { version: 1, entries: {} };
-    }
-    catch (error) {
-        logger.error(`An error occurred while getting downloaded versions: ${error}`);
-        return { version: 1, entries: {} };
-    }
-}
-export function saveDownloadedVersions(configDirectory, lock) {
-    try {
-        // Write the lock file to the repo root
-        const filepath = path.join(process.cwd(), GT_LOCK_FILE);
-        fs.mkdirSync(path.dirname(filepath), { recursive: true });
-        fs.writeFileSync(filepath, JSON.stringify(lock, null, 2));
-    }
-    catch (error) {
-        logger.error(`An error occurred while updating ${GT_LOCK_FILE}: ${error}`);
-    }
-}
-export function ensureNestedObject(obj, path) {
-    return path.reduce((current, key, index) => {
-        if (index === path.length - 1)
-            return current;
-        current[key] = current[key] || {};
-        return current[key];
-    }, obj);
-}

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 | TransformOption[], compositePatterns?: string[]): {
-    resolvedPaths: string[];
-    placeholderPaths: string[];
-};

package/dist/fs/config/parseFilesConfig.js

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

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

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

@@ -1,11 +0,0 @@
-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 {};