gt 2.14.35 → 2.14.36

package/dist/fs/config/parseFilesConfig.js

@@ -1,241 +1,180 @@
-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';
-import { BASE_PARSING_FLAGS_DEFAULT, GT_PARSING_FLAGS_DEFAULT, } from '../../config/defaults.js';
-import { resolveTransformationFormat } from '../../formats/files/transformFormat.js';
+import { logger } from "../../console/logger.js";
+import { SUPPORTED_FILE_EXTENSIONS } from "../../formats/files/supportedFiles.js";
+import { BASE_PARSING_FLAGS_DEFAULT, GT_PARSING_FLAGS_DEFAULT } from "../../config/defaults.js";
+import { resolveTransformationFormat } from "../../formats/files/transformFormat.js";
+import chalk from "chalk";
+import path from "node:path";
+import fg from "fast-glob";
+import micromatch from "micromatch";
+//#region src/fs/config/parseFilesConfig.ts
 /**
- * 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
+* 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
+*/
+function resolveLocaleFiles(files, locale) {
+	const result = {};
+	for (const fileType of SUPPORTED_FILE_EXTENSIONS) result[fileType] = files[fileType]?.map((filepath) => filepath.replace(/\[locale\]/g, locale));
+	result.gt = files.gt?.replace(/\[locale\]/g, locale);
+	return result;
 }
 /**
- * Normalizes include patterns into plain path strings and tracks which
- * patterns have explicit publish flags.
- */
-export function normalizeIncludePatterns(patterns) {
-    const paths = [];
-    const publishPatterns = [];
-    const unpublishPatterns = [];
-    for (const pattern of patterns) {
-        if (typeof pattern === 'string') {
-            paths.push(pattern);
-        }
-        else {
-            paths.push(pattern.pattern);
-            if (pattern.publish === true) {
-                publishPatterns.push(pattern.pattern);
-            }
-            else if (pattern.publish === false) {
-                unpublishPatterns.push(pattern.pattern);
-            }
-        }
-    }
-    return { paths, publishPatterns, unpublishPatterns };
+* Normalizes include patterns into plain path strings and tracks which
+* patterns have explicit publish flags.
+*/
+function normalizeIncludePatterns(patterns) {
+	const paths = [];
+	const publishPatterns = [];
+	const unpublishPatterns = [];
+	for (const pattern of patterns) if (typeof pattern === "string") paths.push(pattern);
+	else {
+		paths.push(pattern.pattern);
+		if (pattern.publish === true) publishPatterns.push(pattern.pattern);
+		else if (pattern.publish === false) unpublishPatterns.push(pattern.pattern);
+	}
+	return {
+		paths,
+		publishPatterns,
+		unpublishPatterns
+	};
 }
 /**
- * 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 resolvedPaths = {};
-    const placeholderResult = {};
-    const transformPaths = {};
-    // Output format transforms are tracked separately from path transforms.
-    const transformFormats = {};
-    const publishPaths = new Set();
-    const unpublishPaths = new Set();
-    const parsingFlags = {};
-    // 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;
-        }
-        // Validate source -> output format transforms during settings generation.
-        const transformFormat = resolveTransformationFormat(fileType, files[fileType]?.transformationFormat);
-        if (transformFormat) {
-            transformFormats[fileType] = transformFormat;
-        }
-        // ==== PLACEHOLDERS ==== //
-        if (files[fileType]?.include) {
-            const { paths, publishPatterns, unpublishPatterns } = normalizeIncludePatterns(files[fileType].include);
-            const filePaths = expandGlobPatterns(cwd, paths, files[fileType]?.exclude || [], locale, locales, transformPaths[fileType] || undefined, compositePatterns);
-            resolvedPaths[fileType] = filePaths.resolvedPaths;
-            placeholderResult[fileType] = filePaths.placeholderPaths;
-            // Classify resolved paths into publish/unpublish sets
-            classifyPublishPaths(filePaths.resolvedPaths, publishPatterns, unpublishPatterns, cwd, locale, publishPaths, unpublishPaths);
-        }
-        // ==== OTHER ==== //
-        if (files[fileType]?.parsingFlags) {
-            parsingFlags[fileType] = {
-                ...BASE_PARSING_FLAGS_DEFAULT,
-                ...files[fileType].parsingFlags,
-            };
-        }
-    }
-    return {
-        resolvedPaths,
-        placeholderPaths: placeholderResult,
-        transformPaths: transformPaths,
-        transformFormats,
-        publishPaths,
-        unpublishPaths,
-        parsingFlags,
-        gtJson: (() => {
-            const rawGtFlags = (files.gt?.parsingFlags || {});
-            if ('autoDerive' in rawGtFlags && !('autoderive' in rawGtFlags)) {
-                rawGtFlags.autoderive = rawGtFlags.autoDerive;
-                delete rawGtFlags.autoDerive;
-            }
-            return {
-                publish: files.gt?.publish,
-                parsingFlags: {
-                    ...GT_PARSING_FLAGS_DEFAULT,
-                    ...rawGtFlags,
-                },
-            };
-        })(),
-    };
+* 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
+*/
+function resolveFiles(files, locale, locales, cwd, compositePatterns) {
+	const resolvedPaths = {};
+	const placeholderResult = {};
+	const transformPaths = {};
+	const transformFormats = {};
+	const publishPaths = /* @__PURE__ */ new Set();
+	const unpublishPaths = /* @__PURE__ */ new Set();
+	const parsingFlags = {};
+	if (files.gt?.output) placeholderResult.gt = path.resolve(cwd, files.gt.output);
+	for (const fileType of SUPPORTED_FILE_EXTENSIONS) {
+		const transform = files[fileType]?.transform;
+		if (transform && (typeof transform === "string" || typeof transform === "object" || Array.isArray(transform))) transformPaths[fileType] = transform;
+		const transformFormat = resolveTransformationFormat(fileType, files[fileType]?.transformationFormat);
+		if (transformFormat) transformFormats[fileType] = transformFormat;
+		if (files[fileType]?.include) {
+			const { paths, publishPatterns, unpublishPatterns } = normalizeIncludePatterns(files[fileType].include);
+			const filePaths = expandGlobPatterns(cwd, paths, files[fileType]?.exclude || [], locale, locales, transformPaths[fileType] || void 0, compositePatterns);
+			resolvedPaths[fileType] = filePaths.resolvedPaths;
+			placeholderResult[fileType] = filePaths.placeholderPaths;
+			classifyPublishPaths(filePaths.resolvedPaths, publishPatterns, unpublishPatterns, cwd, locale, publishPaths, unpublishPaths);
+		}
+		if (files[fileType]?.parsingFlags) parsingFlags[fileType] = {
+			...BASE_PARSING_FLAGS_DEFAULT,
+			...files[fileType].parsingFlags
+		};
+	}
+	return {
+		resolvedPaths,
+		placeholderPaths: placeholderResult,
+		transformPaths,
+		transformFormats,
+		publishPaths,
+		unpublishPaths,
+		parsingFlags,
+		gtJson: (() => {
+			const rawGtFlags = files.gt?.parsingFlags || {};
+			if ("autoDerive" in rawGtFlags && !("autoderive" in rawGtFlags)) {
+				rawGtFlags.autoderive = rawGtFlags.autoDerive;
+				delete rawGtFlags.autoDerive;
+			}
+			return {
+				publish: files.gt?.publish,
+				parsingFlags: {
+					...GT_PARSING_FLAGS_DEFAULT,
+					...rawGtFlags
+				}
+			};
+		})()
+	};
 }
-// 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 expandGlobPatterns(cwd, includePatterns, excludePatterns, locale, locales, transformPatterns, compositePatterns) {
+	const resolvedPaths = [];
+	const placeholderPaths = [];
+	for (const pattern of includePatterns) {
+		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 + 8;
+		}
+		const expandedPattern = pattern.replace(/\[locale\]/g, locale);
+		const absolutePattern = path.resolve(cwd, expandedPattern);
+		const expandedExcludePatterns = Array.from(new Set(excludePatterns.flatMap((p) => locales.map((targetLocale) => path.resolve(cwd, p.replace(/\[locale\]/g, locale).replace(/\[locales\]/g, targetLocale))))));
+		const matches = fg.sync(absolutePattern, {
+			absolute: true,
+			ignore: expandedExcludePatterns
+		});
+		resolvedPaths.push(...matches);
+		matches.forEach((match) => {
+			const absolutePath = path.resolve(cwd, match);
+			const patternPath = path.resolve(cwd, pattern);
+			let originalAbsolutePath = absolutePath;
+			if (localePositions.length > 0) originalAbsolutePath = buildPlaceholderPathFromPattern(patternPath, absolutePath, localeTag);
+			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);
+	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 match = new RegExp(localeRegexSource, flags).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);
+	return value.split(path.sep).join(path.posix.sep);
 }
 /**
- * Classifies resolved file paths into publish/unpublish sets by matching
- * them against the given glob patterns. Uses POSIX paths for micromatch
- * compatibility but stores platform-native paths in the output sets.
- */
+* Classifies resolved file paths into publish/unpublish sets by matching
+* them against the given glob patterns. Uses POSIX paths for micromatch
+* compatibility but stores platform-native paths in the output sets.
+*/
 function classifyPublishPaths(resolvedPaths, publishPatterns, unpublishPatterns, cwd, locale, publishPaths, unpublishPaths) {
-    if (publishPatterns.length === 0 && unpublishPatterns.length === 0)
-        return;
-    const posixPaths = resolvedPaths.map(toPosixPath);
-    const toAbsoluteGlob = (p) => toPosixPath(path.resolve(cwd, p.replace(/\[locale\]/g, locale)));
-    for (const pattern of publishPatterns) {
-        const matched = new Set(micromatch(posixPaths, toAbsoluteGlob(pattern)));
-        for (let i = 0; i < posixPaths.length; i++) {
-            if (matched.has(posixPaths[i])) {
-                publishPaths.add(resolvedPaths[i]);
-            }
-        }
-    }
-    for (const pattern of unpublishPatterns) {
-        const matched = new Set(micromatch(posixPaths, toAbsoluteGlob(pattern)));
-        for (let i = 0; i < posixPaths.length; i++) {
-            if (matched.has(posixPaths[i])) {
-                unpublishPaths.add(resolvedPaths[i]);
-            }
-        }
-    }
+	if (publishPatterns.length === 0 && unpublishPatterns.length === 0) return;
+	const posixPaths = resolvedPaths.map(toPosixPath);
+	const toAbsoluteGlob = (p) => toPosixPath(path.resolve(cwd, p.replace(/\[locale\]/g, locale)));
+	for (const pattern of publishPatterns) {
+		const matched = new Set(micromatch(posixPaths, toAbsoluteGlob(pattern)));
+		for (let i = 0; i < posixPaths.length; i++) if (matched.has(posixPaths[i])) publishPaths.add(resolvedPaths[i]);
+	}
+	for (const pattern of unpublishPatterns) {
+		const matched = new Set(micromatch(posixPaths, toAbsoluteGlob(pattern)));
+		for (let i = 0; i < posixPaths.length; i++) if (matched.has(posixPaths[i])) unpublishPaths.add(resolvedPaths[i]);
+	}
 }
+//#endregion
+export { expandGlobPatterns, normalizeIncludePatterns, resolveFiles, resolveLocaleFiles };
+
+//# sourceMappingURL=parseFilesConfig.js.map

package/dist/fs/config/parseFilesConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseFilesConfig.js","names":[],"sources":["../../../src/fs/config/parseFilesConfig.ts"],"sourcesContent":["import path from 'node:path';\nimport {\n  FilesOptions,\n  IncludePattern,\n  ResolvedFiles,\n  Settings,\n  TransformFormats,\n  TransformFiles,\n  TransformOption,\n} from '../../types/index.js';\nimport fg from 'fast-glob';\nimport { SUPPORTED_FILE_EXTENSIONS } from '../../formats/files/supportedFiles.js';\nimport { logger } from '../../console/logger.js';\nimport chalk from 'chalk';\nimport micromatch from 'micromatch';\nimport { ParseFlagsByFileType } from '../../types/parsing.js';\nimport {\n  BASE_PARSING_FLAGS_DEFAULT,\n  GT_PARSING_FLAGS_DEFAULT,\n} from '../../config/defaults.js';\nimport { resolveTransformationFormat } from '../../formats/files/transformFormat.js';\n\n/**\n * Resolves the files from the files object\n * Replaces [locale] with the actual locale in the files\n *\n * @param files - The files object\n * @param locale - The locale to replace [locale] with\n * @returns The resolved files\n */\nexport function resolveLocaleFiles(\n  files: ResolvedFiles,\n  locale: string\n): ResolvedFiles {\n  const result: ResolvedFiles = {};\n\n  for (const fileType of SUPPORTED_FILE_EXTENSIONS) {\n    result[fileType] = files[fileType]?.map((filepath) =>\n      filepath.replace(/\\[locale\\]/g, locale)\n    );\n  }\n\n  // Replace [locale] with locale in all paths\n  result.gt = files.gt?.replace(/\\[locale\\]/g, locale);\n\n  return result;\n}\n/**\n * Normalizes include patterns into plain path strings and tracks which\n * patterns have explicit publish flags.\n */\nexport function normalizeIncludePatterns(patterns: IncludePattern[]): {\n  paths: string[];\n  publishPatterns: string[];\n  unpublishPatterns: string[];\n} {\n  const paths: string[] = [];\n  const publishPatterns: string[] = [];\n  const unpublishPatterns: string[] = [];\n\n  for (const pattern of patterns) {\n    if (typeof pattern === 'string') {\n      paths.push(pattern);\n    } else {\n      paths.push(pattern.pattern);\n      if (pattern.publish === true) {\n        publishPatterns.push(pattern.pattern);\n      } else if (pattern.publish === false) {\n        unpublishPatterns.push(pattern.pattern);\n      }\n    }\n  }\n\n  return { paths, publishPatterns, unpublishPatterns };\n}\n\n/**\n * Resolves the files from the files object.\n * Performs glob pattern expansion on the files.\n * Replaces [locale] with the actual locale in the files.\n *\n * @param files - The files object\n * @returns The resolved files\n */\nexport function resolveFiles(\n  files: FilesOptions,\n  locale: string,\n  locales: string[],\n  cwd: string,\n  compositePatterns?: string[]\n): Settings['files'] {\n  // Initialize result object with empty arrays for each file type\n  const resolvedPaths: ResolvedFiles = {};\n  const placeholderResult: ResolvedFiles = {};\n  const transformPaths: TransformFiles = {};\n  // Output format transforms are tracked separately from path transforms.\n  const transformFormats: TransformFormats = {};\n  const publishPaths = new Set<string>();\n  const unpublishPaths = new Set<string>();\n  const parsingFlags: ParseFlagsByFileType = {};\n\n  // Process GT files\n  if (files.gt?.output) {\n    placeholderResult.gt = path.resolve(cwd, files.gt.output);\n  }\n\n  for (const fileType of SUPPORTED_FILE_EXTENSIONS) {\n    // ==== TRANSFORMS ==== //\n    const transform = files[fileType]?.transform;\n    if (\n      transform &&\n      (typeof transform === 'string' ||\n        typeof transform === 'object' ||\n        Array.isArray(transform))\n    ) {\n      transformPaths[fileType] = transform;\n    }\n    // Validate source -> output format transforms during settings generation.\n    const transformFormat = resolveTransformationFormat(\n      fileType,\n      files[fileType]?.transformationFormat\n    );\n    if (transformFormat) {\n      transformFormats[fileType] = transformFormat;\n    }\n    // ==== PLACEHOLDERS ==== //\n    if (files[fileType]?.include) {\n      const { paths, publishPatterns, unpublishPatterns } =\n        normalizeIncludePatterns(files[fileType].include);\n\n      const filePaths = expandGlobPatterns(\n        cwd,\n        paths,\n        files[fileType]?.exclude || [],\n        locale,\n        locales,\n        transformPaths[fileType] || undefined,\n        compositePatterns\n      );\n      resolvedPaths[fileType] = filePaths.resolvedPaths;\n      placeholderResult[fileType] = filePaths.placeholderPaths;\n\n      // Classify resolved paths into publish/unpublish sets\n      classifyPublishPaths(\n        filePaths.resolvedPaths,\n        publishPatterns,\n        unpublishPatterns,\n        cwd,\n        locale,\n        publishPaths,\n        unpublishPaths\n      );\n    }\n    // ==== OTHER ==== //\n    if (files[fileType]?.parsingFlags) {\n      parsingFlags[fileType] = {\n        ...BASE_PARSING_FLAGS_DEFAULT,\n        ...files[fileType].parsingFlags,\n      };\n    }\n  }\n\n  return {\n    resolvedPaths,\n    placeholderPaths: placeholderResult,\n    transformPaths: transformPaths,\n    transformFormats,\n    publishPaths,\n    unpublishPaths,\n    parsingFlags,\n    gtJson: (() => {\n      const rawGtFlags = (files.gt?.parsingFlags || {}) as Record<\n        string,\n        unknown\n      >;\n      if ('autoDerive' in rawGtFlags && !('autoderive' in rawGtFlags)) {\n        rawGtFlags.autoderive = rawGtFlags.autoDerive;\n        delete rawGtFlags.autoDerive;\n      }\n      return {\n        publish: files.gt?.publish,\n        parsingFlags: {\n          ...GT_PARSING_FLAGS_DEFAULT,\n          ...rawGtFlags,\n        },\n      };\n    })(),\n  };\n}\n\n// Helper function to expand glob patterns\nexport function expandGlobPatterns(\n  cwd: string,\n  includePatterns: string[],\n  excludePatterns: string[],\n  locale: string,\n  locales: string[],\n  transformPatterns?: TransformOption | string | TransformOption[],\n  compositePatterns?: string[]\n): {\n  resolvedPaths: string[];\n  placeholderPaths: string[];\n} {\n  // Expand glob patterns to include all matching files\n  const resolvedPaths: string[] = [];\n  const placeholderPaths: string[] = [];\n\n  // Process include patterns\n  for (const pattern of includePatterns) {\n    // Track positions where [locale] appears in the original pattern\n    // It must be included in the pattern, otherwise the CLI tool will not be able to find the correct output path\n    // Warn if it's not included\n    // Ignore if is composite pattern\n    if (\n      !pattern.includes('[locale]') &&\n      !transformPatterns &&\n      !compositePatterns?.includes(pattern)\n    ) {\n      logger.warn(\n        chalk.yellow(\n          `Pattern \"${pattern}\" does not include [locale], so the CLI tool may incorrectly save translated files.`\n        )\n      );\n    }\n    const localePositions: number[] = [];\n    let searchIndex = 0;\n    const localeTag = '[locale]';\n\n    while (true) {\n      const foundIndex = pattern.indexOf(localeTag, searchIndex);\n      if (foundIndex === -1) break;\n      localePositions.push(foundIndex);\n      searchIndex = foundIndex + localeTag.length;\n    }\n\n    const expandedPattern = pattern.replace(/\\[locale\\]/g, locale);\n\n    // Resolve the absolute pattern path\n    const absolutePattern = path.resolve(cwd, expandedPattern);\n\n    // Prepare exclude patterns with locale replaced\n    const expandedExcludePatterns = Array.from(\n      new Set(\n        excludePatterns.flatMap((p) =>\n          locales.map((targetLocale) =>\n            path.resolve(\n              cwd,\n              p\n                .replace(/\\[locale\\]/g, locale)\n                .replace(/\\[locales\\]/g, targetLocale)\n            )\n          )\n        )\n      )\n    );\n\n    // Use fast-glob to find all matching files, excluding the patterns\n    const matches = fg.sync(absolutePattern, {\n      absolute: true,\n      ignore: expandedExcludePatterns,\n    });\n\n    resolvedPaths.push(...matches);\n\n    // For each match, create a version with [locale] in the correct positions\n    matches.forEach((match) => {\n      const absolutePath = path.resolve(cwd, match);\n      const patternPath = path.resolve(cwd, pattern);\n      let originalAbsolutePath = absolutePath;\n\n      if (localePositions.length > 0) {\n        const placeholderPath = buildPlaceholderPathFromPattern(\n          patternPath,\n          absolutePath,\n          localeTag\n        );\n        originalAbsolutePath = placeholderPath;\n      }\n\n      placeholderPaths.push(originalAbsolutePath);\n    });\n  }\n\n  return { resolvedPaths, placeholderPaths };\n}\n\nfunction buildPlaceholderPathFromPattern(\n  patternPath: string,\n  absolutePath: string,\n  localeTag: string\n): string {\n  if (!patternPath.includes(localeTag)) {\n    return absolutePath;\n  }\n\n  const posixPattern = toPosixPath(patternPath);\n  const posixPath = toPosixPath(absolutePath);\n\n  const baseRegex = micromatch.makeRe(posixPattern, {\n    literalBrackets: true,\n  });\n  const localeRegexSource = baseRegex.source.replace(\n    /\\\\\\[locale\\\\\\]/g,\n    '([^/]+)'\n  );\n  const flags = baseRegex.flags.includes('d')\n    ? baseRegex.flags\n    : `${baseRegex.flags}d`;\n  const matcher = new RegExp(localeRegexSource, flags);\n  const match = matcher.exec(posixPath);\n\n  const matchWithIndices = match as RegExpExecArray & {\n    indices?: Array<[number, number]>;\n  };\n\n  if (!match || !matchWithIndices.indices) {\n    return absolutePath;\n  }\n\n  let placeholderPosixPath = posixPath;\n  const indices = matchWithIndices.indices;\n\n  for (let i = indices.length - 1; i >= 1; i--) {\n    const [start, end] = indices[i];\n    if (start === -1 || end === -1) continue;\n    placeholderPosixPath =\n      placeholderPosixPath.slice(0, start) +\n      localeTag +\n      placeholderPosixPath.slice(end);\n  }\n\n  return path.normalize(placeholderPosixPath);\n}\n\nfunction toPosixPath(value: string): string {\n  return value.split(path.sep).join(path.posix.sep);\n}\n\n/**\n * Classifies resolved file paths into publish/unpublish sets by matching\n * them against the given glob patterns. Uses POSIX paths for micromatch\n * compatibility but stores platform-native paths in the output sets.\n */\nfunction classifyPublishPaths(\n  resolvedPaths: string[],\n  publishPatterns: string[],\n  unpublishPatterns: string[],\n  cwd: string,\n  locale: string,\n  publishPaths: Set<string>,\n  unpublishPaths: Set<string>\n): void {\n  if (publishPatterns.length === 0 && unpublishPatterns.length === 0) return;\n\n  const posixPaths = resolvedPaths.map(toPosixPath);\n  const toAbsoluteGlob = (p: string) =>\n    toPosixPath(path.resolve(cwd, p.replace(/\\[locale\\]/g, locale)));\n\n  for (const pattern of publishPatterns) {\n    const matched = new Set(micromatch(posixPaths, toAbsoluteGlob(pattern)));\n    for (let i = 0; i < posixPaths.length; i++) {\n      if (matched.has(posixPaths[i])) {\n        publishPaths.add(resolvedPaths[i]);\n      }\n    }\n  }\n\n  for (const pattern of unpublishPatterns) {\n    const matched = new Set(micromatch(posixPaths, toAbsoluteGlob(pattern)));\n    for (let i = 0; i < posixPaths.length; i++) {\n      if (matched.has(posixPaths[i])) {\n        unpublishPaths.add(resolvedPaths[i]);\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA8BA,SAAgB,mBACd,OACA,QACe;CACf,MAAM,SAAwB,EAAE;AAEhC,MAAK,MAAM,YAAY,0BACrB,QAAO,YAAY,MAAM,WAAW,KAAK,aACvC,SAAS,QAAQ,eAAe,OAAO,CACxC;AAIH,QAAO,KAAK,MAAM,IAAI,QAAQ,eAAe,OAAO;AAEpD,QAAO;;;;;;AAMT,SAAgB,yBAAyB,UAIvC;CACA,MAAM,QAAkB,EAAE;CAC1B,MAAM,kBAA4B,EAAE;CACpC,MAAM,oBAA8B,EAAE;AAEtC,MAAK,MAAM,WAAW,SACpB,KAAI,OAAO,YAAY,SACrB,OAAM,KAAK,QAAQ;MACd;AACL,QAAM,KAAK,QAAQ,QAAQ;AAC3B,MAAI,QAAQ,YAAY,KACtB,iBAAgB,KAAK,QAAQ,QAAQ;WAC5B,QAAQ,YAAY,MAC7B,mBAAkB,KAAK,QAAQ,QAAQ;;AAK7C,QAAO;EAAE;EAAO;EAAiB;EAAmB;;;;;;;;;;AAWtD,SAAgB,aACd,OACA,QACA,SACA,KACA,mBACmB;CAEnB,MAAM,gBAA+B,EAAE;CACvC,MAAM,oBAAmC,EAAE;CAC3C,MAAM,iBAAiC,EAAE;CAEzC,MAAM,mBAAqC,EAAE;CAC7C,MAAM,+BAAe,IAAI,KAAa;CACtC,MAAM,iCAAiB,IAAI,KAAa;CACxC,MAAM,eAAqC,EAAE;AAG7C,KAAI,MAAM,IAAI,OACZ,mBAAkB,KAAK,KAAK,QAAQ,KAAK,MAAM,GAAG,OAAO;AAG3D,MAAK,MAAM,YAAY,2BAA2B;EAEhD,MAAM,YAAY,MAAM,WAAW;AACnC,MACE,cACC,OAAO,cAAc,YACpB,OAAO,cAAc,YACrB,MAAM,QAAQ,UAAU,EAE1B,gBAAe,YAAY;EAG7B,MAAM,kBAAkB,4BACtB,UACA,MAAM,WAAW,qBAClB;AACD,MAAI,gBACF,kBAAiB,YAAY;AAG/B,MAAI,MAAM,WAAW,SAAS;GAC5B,MAAM,EAAE,OAAO,iBAAiB,sBAC9B,yBAAyB,MAAM,UAAU,QAAQ;GAEnD,MAAM,YAAY,mBAChB,KACA,OACA,MAAM,WAAW,WAAW,EAAE,EAC9B,QACA,SACA,eAAe,aAAa,KAAA,GAC5B,kBACD;AACD,iBAAc,YAAY,UAAU;AACpC,qBAAkB,YAAY,UAAU;AAGxC,wBACE,UAAU,eACV,iBACA,mBACA,KACA,QACA,cACA,eACD;;AAGH,MAAI,MAAM,WAAW,aACnB,cAAa,YAAY;GACvB,GAAG;GACH,GAAG,MAAM,UAAU;GACpB;;AAIL,QAAO;EACL;EACA,kBAAkB;EACF;EAChB;EACA;EACA;EACA;EACA,eAAe;GACb,MAAM,aAAc,MAAM,IAAI,gBAAgB,EAAE;AAIhD,OAAI,gBAAgB,cAAc,EAAE,gBAAgB,aAAa;AAC/D,eAAW,aAAa,WAAW;AACnC,WAAO,WAAW;;AAEpB,UAAO;IACL,SAAS,MAAM,IAAI;IACnB,cAAc;KACZ,GAAG;KACH,GAAG;KACJ;IACF;MACC;EACL;;AAIH,SAAgB,mBACd,KACA,iBACA,iBACA,QACA,SACA,mBACA,mBAIA;CAEA,MAAM,gBAA0B,EAAE;CAClC,MAAM,mBAA6B,EAAE;AAGrC,MAAK,MAAM,WAAW,iBAAiB;AAKrC,MACE,CAAC,QAAQ,SAAS,WAAW,IAC7B,CAAC,qBACD,CAAC,mBAAmB,SAAS,QAAQ,CAErC,QAAO,KACL,MAAM,OACJ,YAAY,QAAQ,qFACrB,CACF;EAEH,MAAM,kBAA4B,EAAE;EACpC,IAAI,cAAc;EAClB,MAAM,YAAY;AAElB,SAAO,MAAM;GACX,MAAM,aAAa,QAAQ,QAAQ,WAAW,YAAY;AAC1D,OAAI,eAAe,GAAI;AACvB,mBAAgB,KAAK,WAAW;AAChC,iBAAc,aAAa;;EAG7B,MAAM,kBAAkB,QAAQ,QAAQ,eAAe,OAAO;EAG9D,MAAM,kBAAkB,KAAK,QAAQ,KAAK,gBAAgB;EAG1D,MAAM,0BAA0B,MAAM,KACpC,IAAI,IACF,gBAAgB,SAAS,MACvB,QAAQ,KAAK,iBACX,KAAK,QACH,KACA,EACG,QAAQ,eAAe,OAAO,CAC9B,QAAQ,gBAAgB,aAAa,CACzC,CACF,CACF,CACF,CACF;EAGD,MAAM,UAAU,GAAG,KAAK,iBAAiB;GACvC,UAAU;GACV,QAAQ;GACT,CAAC;AAEF,gBAAc,KAAK,GAAG,QAAQ;AAG9B,UAAQ,SAAS,UAAU;GACzB,MAAM,eAAe,KAAK,QAAQ,KAAK,MAAM;GAC7C,MAAM,cAAc,KAAK,QAAQ,KAAK,QAAQ;GAC9C,IAAI,uBAAuB;AAE3B,OAAI,gBAAgB,SAAS,EAM3B,wBALwB,gCACtB,aACA,cACA,UAEoC;AAGxC,oBAAiB,KAAK,qBAAqB;IAC3C;;AAGJ,QAAO;EAAE;EAAe;EAAkB;;AAG5C,SAAS,gCACP,aACA,cACA,WACQ;AACR,KAAI,CAAC,YAAY,SAAS,UAAU,CAClC,QAAO;CAGT,MAAM,eAAe,YAAY,YAAY;CAC7C,MAAM,YAAY,YAAY,aAAa;CAE3C,MAAM,YAAY,WAAW,OAAO,cAAc,EAChD,iBAAiB,MAClB,CAAC;CACF,MAAM,oBAAoB,UAAU,OAAO,QACzC,mBACA,UACD;CACD,MAAM,QAAQ,UAAU,MAAM,SAAS,IAAI,GACvC,UAAU,QACV,GAAG,UAAU,MAAM;CAEvB,MAAM,QAAQ,IADM,OAAO,mBAAmB,MACzB,CAAC,KAAK,UAAU;CAErC,MAAM,mBAAmB;AAIzB,KAAI,CAAC,SAAS,CAAC,iBAAiB,QAC9B,QAAO;CAGT,IAAI,uBAAuB;CAC3B,MAAM,UAAU,iBAAiB;AAEjC,MAAK,IAAI,IAAI,QAAQ,SAAS,GAAG,KAAK,GAAG,KAAK;EAC5C,MAAM,CAAC,OAAO,OAAO,QAAQ;AAC7B,MAAI,UAAU,MAAM,QAAQ,GAAI;AAChC,yBACE,qBAAqB,MAAM,GAAG,MAAM,GACpC,YACA,qBAAqB,MAAM,IAAI;;AAGnC,QAAO,KAAK,UAAU,qBAAqB;;AAG7C,SAAS,YAAY,OAAuB;AAC1C,QAAO,MAAM,MAAM,KAAK,IAAI,CAAC,KAAK,KAAK,MAAM,IAAI;;;;;;;AAQnD,SAAS,qBACP,eACA,iBACA,mBACA,KACA,QACA,cACA,gBACM;AACN,KAAI,gBAAgB,WAAW,KAAK,kBAAkB,WAAW,EAAG;CAEpE,MAAM,aAAa,cAAc,IAAI,YAAY;CACjD,MAAM,kBAAkB,MACtB,YAAY,KAAK,QAAQ,KAAK,EAAE,QAAQ,eAAe,OAAO,CAAC,CAAC;AAElE,MAAK,MAAM,WAAW,iBAAiB;EACrC,MAAM,UAAU,IAAI,IAAI,WAAW,YAAY,eAAe,QAAQ,CAAC,CAAC;AACxE,OAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,IACrC,KAAI,QAAQ,IAAI,WAAW,GAAG,CAC5B,cAAa,IAAI,cAAc,GAAG;;AAKxC,MAAK,MAAM,WAAW,mBAAmB;EACvC,MAAM,UAAU,IAAI,IAAI,WAAW,YAAY,eAAe,QAAQ,CAAC,CAAC;AACxE,OAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,IACrC,KAAI,QAAQ,IAAI,WAAW,GAAG,CAC5B,gBAAe,IAAI,cAAc,GAAG"}

package/dist/fs/config/setupConfig.js

@@ -1,54 +1,45 @@
-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';
+import { logger } from "../../console/logger.js";
+import { GT_CONFIG_SCHEMA_URL } from "../../utils/constants.js";
+import { displayCreatedConfigFile } from "../../console/logging.js";
+import fs from "node:fs";
+//#region src/fs/config/setupConfig.ts
 /**
- * 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)) {
-            const parsed = JSON.parse(await fs.promises.readFile(configFilepath, 'utf-8'));
-            oldContent =
-                typeof parsed === 'object' && parsed !== null
-                    ? parsed
-                    : {};
-        }
-        // 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;
+* 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.
+*/
+async function createOrUpdateConfig(configFilepath, options) {
+	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 {
+		let oldContent = {};
+		if (fs.existsSync(configFilepath)) {
+			const parsed = JSON.parse(await fs.promises.readFile(configFilepath, "utf-8"));
+			oldContent = typeof parsed === "object" && parsed !== null ? parsed : {};
+		}
+		const mergedContent = {
+			$schema: GT_CONFIG_SCHEMA_URL,
+			...oldContent,
+			...newContent
+		};
+		if (options.locales) mergedContent.locales = mergedContent.locales ? [...new Set([...mergedContent.locales, ...options.locales])] : options.locales;
+		const mergedJsonContent = JSON.stringify(mergedContent, null, 2);
+		await fs.promises.writeFile(configFilepath, mergedJsonContent, "utf-8");
+		displayCreatedConfigFile(configFilepath);
+	} catch (error) {
+		logger.error(`An error occurred while updating ${configFilepath}: ${error}`);
+	}
+	return configFilepath;
 }
+//#endregion
+export { createOrUpdateConfig };
+
+//# sourceMappingURL=setupConfig.js.map

package/dist/fs/config/setupConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setupConfig.js","names":[],"sources":["../../../src/fs/config/setupConfig.ts"],"sourcesContent":["import fs from 'node:fs';\nimport { displayCreatedConfigFile } from '../../console/logging.js';\nimport { FilesOptions, SupportedFrameworks } from '../../types/index.js';\nimport { logger } from '../../console/logger.js';\nimport { GT_CONFIG_SCHEMA_URL } from '../../utils/constants.js';\n\n/**\n * Checks if the config file exists.\n * If yes, make sure make sure projectId is correct\n * If not, creates a new JSON file at the given filepath and writes the provided config object to it.\n * @param {string} configFilepath - The path to the config file.\n * @param {Record<string, any>} configObject - The config object to write if the file does not exist.\n */\nexport async function createOrUpdateConfig(\n  configFilepath: string,\n  options: {\n    projectId?: string;\n    defaultLocale?: string;\n    locales?: string[];\n    files?: FilesOptions;\n    framework?: SupportedFrameworks;\n    baseUrl?: string;\n    publish?: boolean;\n  }\n): Promise<string> {\n  // Filter out empty string values from the config object\n  const newContent = {\n    ...(options.projectId && { projectId: options.projectId }),\n    ...(options.defaultLocale && { defaultLocale: options.defaultLocale }),\n    ...(options.files && { files: options.files }),\n    ...(options.framework && { framework: options.framework }),\n    ...(options.baseUrl && { baseUrl: options.baseUrl }),\n    ...(options.publish && { publish: options.publish }),\n  };\n  try {\n    // if file exists\n    let oldContent: Record<string, unknown> = {};\n    if (fs.existsSync(configFilepath)) {\n      const parsed = JSON.parse(\n        await fs.promises.readFile(configFilepath, 'utf-8')\n      );\n      oldContent =\n        typeof parsed === 'object' && parsed !== null\n          ? (parsed as Record<string, unknown>)\n          : {};\n    }\n\n    // merge old and new content\n    const mergedContent = {\n      $schema: GT_CONFIG_SCHEMA_URL,\n      ...oldContent,\n      ...newContent,\n    } as Record<string, unknown> & { locales?: string[] };\n\n    // Add locales to mergedContent if they exist\n    if (options.locales) {\n      mergedContent.locales = mergedContent.locales\n        ? [...new Set([...mergedContent.locales, ...options.locales])]\n        : options.locales;\n    }\n\n    // write to file\n    const mergedJsonContent = JSON.stringify(mergedContent, null, 2);\n    await fs.promises.writeFile(configFilepath, mergedJsonContent, 'utf-8');\n\n    // show update in console\n    displayCreatedConfigFile(configFilepath);\n  } catch (error) {\n    logger.error(\n      `An error occurred while updating ${configFilepath}: ${error}`\n    );\n  }\n  return configFilepath;\n}\n"],"mappings":";;;;;;;;;;;;AAaA,eAAsB,qBACpB,gBACA,SASiB;CAEjB,MAAM,aAAa;EACjB,GAAI,QAAQ,aAAa,EAAE,WAAW,QAAQ,WAAW;EACzD,GAAI,QAAQ,iBAAiB,EAAE,eAAe,QAAQ,eAAe;EACrE,GAAI,QAAQ,SAAS,EAAE,OAAO,QAAQ,OAAO;EAC7C,GAAI,QAAQ,aAAa,EAAE,WAAW,QAAQ,WAAW;EACzD,GAAI,QAAQ,WAAW,EAAE,SAAS,QAAQ,SAAS;EACnD,GAAI,QAAQ,WAAW,EAAE,SAAS,QAAQ,SAAS;EACpD;AACD,KAAI;EAEF,IAAI,aAAsC,EAAE;AAC5C,MAAI,GAAG,WAAW,eAAe,EAAE;GACjC,MAAM,SAAS,KAAK,MAClB,MAAM,GAAG,SAAS,SAAS,gBAAgB,QAAQ,CACpD;AACD,gBACE,OAAO,WAAW,YAAY,WAAW,OACpC,SACD,EAAE;;EAIV,MAAM,gBAAgB;GACpB,SAAS;GACT,GAAG;GACH,GAAG;GACJ;AAGD,MAAI,QAAQ,QACV,eAAc,UAAU,cAAc,UAClC,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,cAAc,SAAS,GAAG,QAAQ,QAAQ,CAAC,CAAC,GAC5D,QAAQ;EAId,MAAM,oBAAoB,KAAK,UAAU,eAAe,MAAM,EAAE;AAChE,QAAM,GAAG,SAAS,UAAU,gBAAgB,mBAAmB,QAAQ;AAGvE,2BAAyB,eAAe;UACjC,OAAO;AACd,SAAO,MACL,oCAAoC,eAAe,IAAI,QACxD;;AAEH,QAAO"}