gt 2.14.35 → 2.14.37

package/dist/formats/utils.js

@@ -1,24 +1,14 @@
-// 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;
-    });
+//#region src/formats/utils.ts
+function replaceLocalePlaceholders(string, localeProperties) {
+	return string.replace(/\{(\w+)\}/g, (match, property) => {
+		if (property === "locale" || property === "localeCode") return localeProperties.code;
+		if (property === "localeName") return localeProperties.name;
+		if (property === "localeNativeName") return localeProperties.nativeName;
+		if (property in localeProperties) return localeProperties[property];
+		return match;
+	});
 }
+//#endregion
+export { replaceLocalePlaceholders };
+
+//# sourceMappingURL=utils.js.map

package/dist/formats/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../src/formats/utils.ts"],"sourcesContent":["import type { LocaleProperties } from '@generaltranslation/format/types';\n\n// helper function to replace locale placeholders in a string\n// with the corresponding locale properties\n// ex: {locale} -> will be replaced with the locale code\n// ex: {localeName} -> will be replaced with the locale name\nexport function replaceLocalePlaceholders(\n  string: string,\n  localeProperties: LocaleProperties\n): string {\n  return string.replace(/\\{(\\w+)\\}/g, (match, property) => {\n    // Handle common aliases\n    if (property === 'locale' || property === 'localeCode') {\n      return localeProperties.code;\n    }\n    if (property === 'localeName') {\n      return localeProperties.name;\n    }\n    if (property === 'localeNativeName') {\n      return localeProperties.nativeName;\n    }\n    // Check if the property exists in localeProperties\n    if (property in localeProperties) {\n      return localeProperties[property as keyof typeof localeProperties];\n    }\n    // Return the original placeholder if property not found\n    return match;\n  });\n}\n"],"mappings":";AAMA,SAAgB,0BACd,QACA,kBACQ;AACR,QAAO,OAAO,QAAQ,eAAe,OAAO,aAAa;AAEvD,MAAI,aAAa,YAAY,aAAa,aACxC,QAAO,iBAAiB;AAE1B,MAAI,aAAa,aACf,QAAO,iBAAiB;AAE1B,MAAI,aAAa,mBACf,QAAO,iBAAiB;AAG1B,MAAI,YAAY,iBACd,QAAO,iBAAiB;AAG1B,SAAO;GACP"}

package/dist/formats/yaml/extractYaml.js

@@ -1,33 +1,34 @@
-import { logger } from '../../console/logger.js';
-import { validateYamlSchema } from './utils.js';
-import { flattenJsonWithStringFilter } from '../json/flattenJson.js';
-import YAML from 'yaml';
+import { logger } from "../../console/logger.js";
+import { flattenJsonWithStringFilter } from "../json/flattenJson.js";
+import { validateYamlSchema } from "./utils.js";
+import YAML from "yaml";
+//#region src/formats/yaml/extractYaml.ts
 /**
- * Extracts translated values from a fully merged YAML file back into the
- * flattened JSON pointer format that mergeYaml expects.
- * This is the inverse of mergeYaml — it takes a merged YAML document and
- * extracts only the values at the schema's include paths.
- *
- * @param localContent - The full YAML content from the user's local file
- * @param inputPath - The path to the file (used for matching yamlSchema)
- * @param options - Additional options containing yamlSchema config
- * @returns The flattened JSON string of translatable values, or null if no extraction needed
- */
-export function extractYaml(localContent, inputPath, options) {
-    const yamlSchema = validateYamlSchema(options, inputPath);
-    if (!yamlSchema || !yamlSchema.include) {
-        return null;
-    }
-    let yaml;
-    try {
-        yaml = YAML.parse(localContent);
-    }
-    catch {
-        logger.error(`Invalid YAML file: ${inputPath}`);
-        return null;
-    }
-    const extracted = flattenJsonWithStringFilter(yaml, yamlSchema.include);
-    if (!Object.keys(extracted).length)
-        return null;
-    return JSON.stringify(extracted);
+* Extracts translated values from a fully merged YAML file back into the
+* flattened JSON pointer format that mergeYaml expects.
+* This is the inverse of mergeYaml — it takes a merged YAML document and
+* extracts only the values at the schema's include paths.
+*
+* @param localContent - The full YAML content from the user's local file
+* @param inputPath - The path to the file (used for matching yamlSchema)
+* @param options - Additional options containing yamlSchema config
+* @returns The flattened JSON string of translatable values, or null if no extraction needed
+*/
+function extractYaml(localContent, inputPath, options) {
+	const yamlSchema = validateYamlSchema(options, inputPath);
+	if (!yamlSchema || !yamlSchema.include) return null;
+	let yaml;
+	try {
+		yaml = YAML.parse(localContent);
+	} catch {
+		logger.error(`Invalid YAML file: ${inputPath}`);
+		return null;
+	}
+	const extracted = flattenJsonWithStringFilter(yaml, yamlSchema.include);
+	if (!Object.keys(extracted).length) return null;
+	return JSON.stringify(extracted);
 }
+//#endregion
+export { extractYaml };
+
+//# sourceMappingURL=extractYaml.js.map

package/dist/formats/yaml/extractYaml.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractYaml.js","names":[],"sources":["../../../src/formats/yaml/extractYaml.ts"],"sourcesContent":["import { AdditionalOptions } from '../../types/index.js';\nimport { logger } from '../../console/logger.js';\nimport { validateYamlSchema } from './utils.js';\nimport { flattenJsonWithStringFilter } from '../json/flattenJson.js';\nimport YAML from 'yaml';\n\n/**\n * Extracts translated values from a fully merged YAML file back into the\n * flattened JSON pointer format that mergeYaml expects.\n * This is the inverse of mergeYaml — it takes a merged YAML document and\n * extracts only the values at the schema's include paths.\n *\n * @param localContent - The full YAML content from the user's local file\n * @param inputPath - The path to the file (used for matching yamlSchema)\n * @param options - Additional options containing yamlSchema config\n * @returns The flattened JSON string of translatable values, or null if no extraction needed\n */\nexport function extractYaml(\n  localContent: string,\n  inputPath: string,\n  options: AdditionalOptions\n): string | null {\n  const yamlSchema = validateYamlSchema(options, inputPath);\n  if (!yamlSchema || !yamlSchema.include) {\n    return null;\n  }\n\n  let yaml: Record<string, unknown>;\n  try {\n    yaml = YAML.parse(localContent);\n  } catch {\n    logger.error(`Invalid YAML file: ${inputPath}`);\n    return null;\n  }\n\n  const extracted = flattenJsonWithStringFilter(yaml, yamlSchema.include);\n  if (!Object.keys(extracted).length) return null;\n  return JSON.stringify(extracted);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAiBA,SAAgB,YACd,cACA,WACA,SACe;CACf,MAAM,aAAa,mBAAmB,SAAS,UAAU;AACzD,KAAI,CAAC,cAAc,CAAC,WAAW,QAC7B,QAAO;CAGT,IAAI;AACJ,KAAI;AACF,SAAO,KAAK,MAAM,aAAa;SACzB;AACN,SAAO,MAAM,sBAAsB,YAAY;AAC/C,SAAO;;CAGT,MAAM,YAAY,4BAA4B,MAAM,WAAW,QAAQ;AACvE,KAAI,CAAC,OAAO,KAAK,UAAU,CAAC,OAAQ,QAAO;AAC3C,QAAO,KAAK,UAAU,UAAU"}

package/dist/formats/yaml/mergeYaml.js

@@ -1,61 +1,44 @@
-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;
+import { logger } from "../../console/logger.js";
+import { exitSync } from "../../console/logging.js";
+import { validateYamlSchema } from "./utils.js";
+import { applyTransformations } from "../json/mergeJson.js";
+import JSONPointer from "jsonpointer";
+import YAML from "yaml";
+//#region src/formats/yaml/mergeYaml.ts
+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);
+	}
+	if (!yamlSchema.include) {
+		logger.error("No include property found in YAML schema");
+		return exitSync(1);
+	}
+	const output = [];
+	for (const target of targets) {
+		const mergedYaml = JSON.parse(JSON.stringify(originalYaml));
+		let translatedJson;
+		try {
+			translatedJson = JSON.parse(target.translatedContent);
+		} catch {
+			translatedJson = {};
+		}
+		for (const [jsonPointer, translatedValue] of Object.entries(translatedJson)) try {
+			if (JSONPointer.get(mergedYaml, jsonPointer) == null) continue;
+			JSONPointer.set(mergedYaml, jsonPointer, translatedValue);
+		} catch {}
+		if (yamlSchema.transform) applyTransformations(mergedYaml, yamlSchema.transform, target.targetLocale, defaultLocale);
+		output.push(YAML.stringify(mergedYaml));
+	}
+	if (!output.length) return [originalContent];
+	return output;
 }
+//#endregion
+export { mergeYaml as default };
+
+//# sourceMappingURL=mergeYaml.js.map

package/dist/formats/yaml/mergeYaml.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeYaml.js","names":[],"sources":["../../../src/formats/yaml/mergeYaml.ts"],"sourcesContent":["import JSONPointer from 'jsonpointer';\nimport { exitSync } from '../../console/logging.js';\nimport { logger } from '../../console/logger.js';\nimport { AdditionalOptions } from '../../types/index.js';\nimport { validateYamlSchema } from './utils.js';\nimport YAML from 'yaml';\nimport { applyTransformations } from '../json/mergeJson.js';\n\nexport default function mergeYaml(\n  originalContent: string,\n  inputPath: string,\n  options: AdditionalOptions,\n  targets: {\n    translatedContent: string;\n    targetLocale: string;\n  }[],\n  defaultLocale: string\n): string[] {\n  const yamlSchema = validateYamlSchema(options, inputPath);\n  if (!yamlSchema) {\n    return targets.map((target) => target.translatedContent);\n  }\n\n  let originalYaml: unknown;\n  try {\n    originalYaml = YAML.parse(originalContent);\n  } catch {\n    logger.error(`Invalid YAML file: ${inputPath}`);\n    return exitSync(1);\n  }\n  // Unreachable (validated in validateYamlSchema, included for type check)\n  if (!yamlSchema.include) {\n    logger.error('No include property found in YAML schema');\n    return exitSync(1);\n  }\n\n  // Handle include\n  const output: string[] = [];\n  for (const target of targets) {\n    // Must clone the original YAML to avoid mutations\n    const mergedYaml = JSON.parse(JSON.stringify(originalYaml));\n\n    let translatedJson: Record<string, unknown>;\n    try {\n      translatedJson = JSON.parse(target.translatedContent);\n    } catch {\n      // If parsing fails, treat as empty object to avoid crashes\n      translatedJson = {};\n    }\n\n    for (const [jsonPointer, translatedValue] of Object.entries(\n      translatedJson\n    )) {\n      try {\n        // Try to get the value - if this succeeds, the pointer exists\n        if (JSONPointer.get(mergedYaml, jsonPointer) == null) {\n          continue;\n        }\n        // Set the new value regardless of what the current value is (including null/falsy)\n        JSONPointer.set(mergedYaml, jsonPointer, translatedValue);\n      } catch {\n        // Silently ignore invalid or non-existent JSON pointers\n      }\n    }\n\n    // Apply transformations if they exist\n    if (yamlSchema.transform) {\n      applyTransformations(\n        mergedYaml,\n        yamlSchema.transform,\n        target.targetLocale,\n        defaultLocale\n      );\n    }\n\n    output.push(YAML.stringify(mergedYaml));\n  }\n\n  if (!output.length) {\n    return [originalContent];\n  }\n\n  return output;\n}\n"],"mappings":";;;;;;;AAQA,SAAwB,UACtB,iBACA,WACA,SACA,SAIA,eACU;CACV,MAAM,aAAa,mBAAmB,SAAS,UAAU;AACzD,KAAI,CAAC,WACH,QAAO,QAAQ,KAAK,WAAW,OAAO,kBAAkB;CAG1D,IAAI;AACJ,KAAI;AACF,iBAAe,KAAK,MAAM,gBAAgB;SACpC;AACN,SAAO,MAAM,sBAAsB,YAAY;AAC/C,SAAO,SAAS,EAAE;;AAGpB,KAAI,CAAC,WAAW,SAAS;AACvB,SAAO,MAAM,2CAA2C;AACxD,SAAO,SAAS,EAAE;;CAIpB,MAAM,SAAmB,EAAE;AAC3B,MAAK,MAAM,UAAU,SAAS;EAE5B,MAAM,aAAa,KAAK,MAAM,KAAK,UAAU,aAAa,CAAC;EAE3D,IAAI;AACJ,MAAI;AACF,oBAAiB,KAAK,MAAM,OAAO,kBAAkB;UAC/C;AAEN,oBAAiB,EAAE;;AAGrB,OAAK,MAAM,CAAC,aAAa,oBAAoB,OAAO,QAClD,eACD,CACC,KAAI;AAEF,OAAI,YAAY,IAAI,YAAY,YAAY,IAAI,KAC9C;AAGF,eAAY,IAAI,YAAY,aAAa,gBAAgB;UACnD;AAMV,MAAI,WAAW,UACb,sBACE,YACA,WAAW,WACX,OAAO,cACP,cACD;AAGH,SAAO,KAAK,KAAK,UAAU,WAAW,CAAC;;AAGzC,KAAI,CAAC,OAAO,OACV,QAAO,CAAC,gBAAgB;AAG1B,QAAO"}

package/dist/formats/yaml/parseYaml.js

@@ -1,24 +1,35 @@
-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' };
+import { logger } from "../../console/logger.js";
+import { exitSync } from "../../console/logging.js";
+import { flattenJsonWithStringFilter } from "../json/flattenJson.js";
+import { validateYamlSchema } from "./utils.js";
+import YAML from "yaml";
+//#region src/formats/yaml/parseYaml.ts
+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"
+	};
 }
+//#endregion
+export { parseYaml as default };
+
+//# sourceMappingURL=parseYaml.js.map

package/dist/formats/yaml/parseYaml.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseYaml.js","names":[],"sources":["../../../src/formats/yaml/parseYaml.ts"],"sourcesContent":["import { AdditionalOptions } from '../../types/index.js';\nimport { exitSync } from '../../console/logging.js';\nimport { logger } from '../../console/logger.js';\nimport YAML from 'yaml';\nimport { validateYamlSchema } from './utils.js';\nimport { flattenJsonWithStringFilter } from '../json/flattenJson.js';\n\nexport default function parseYaml(\n  content: string,\n  filePath: string,\n  options: AdditionalOptions\n): { content: string; fileFormat: 'JSON' | 'YAML' } {\n  const yamlSchema = validateYamlSchema(options, filePath);\n  if (!yamlSchema) {\n    return { content, fileFormat: 'YAML' };\n  }\n\n  let yaml: unknown;\n  try {\n    yaml = YAML.parse(content);\n  } catch {\n    logger.error(`Invalid YAML file: ${filePath}`);\n    return exitSync(1);\n  }\n\n  if (yamlSchema.include) {\n    const flattenedYaml = flattenJsonWithStringFilter(yaml, yamlSchema.include);\n    return { content: JSON.stringify(flattenedYaml), fileFormat: 'JSON' };\n  }\n\n  return { content, fileFormat: 'YAML' };\n}\n"],"mappings":";;;;;;AAOA,SAAwB,UACtB,SACA,UACA,SACkD;CAClD,MAAM,aAAa,mBAAmB,SAAS,SAAS;AACxD,KAAI,CAAC,WACH,QAAO;EAAE;EAAS,YAAY;EAAQ;CAGxC,IAAI;AACJ,KAAI;AACF,SAAO,KAAK,MAAM,QAAQ;SACpB;AACN,SAAO,MAAM,sBAAsB,WAAW;AAC9C,SAAO,SAAS,EAAE;;AAGpB,KAAI,WAAW,SAAS;EACtB,MAAM,gBAAgB,4BAA4B,MAAM,WAAW,QAAQ;AAC3E,SAAO;GAAE,SAAS,KAAK,UAAU,cAAc;GAAE,YAAY;GAAQ;;AAGvE,QAAO;EAAE;EAAS,YAAY;EAAQ"}

package/dist/formats/yaml/utils.js

@@ -1,23 +1,21 @@
-import { exitSync } from '../../console/logging.js';
-import { logger } from '../../console/logger.js';
-import micromatch from 'micromatch';
+import { logger } from "../../console/logger.js";
+import { exitSync } from "../../console/logging.js";
+import micromatch from "micromatch";
+import path from "path";
+//#region src/formats/yaml/utils.ts
 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;
+function validateYamlSchema(options, filePath) {
+	if (!options.yamlSchema) return null;
+	const matchingGlob = Object.keys(options.yamlSchema).find((fileGlob) => isMatch(path.relative(process.cwd(), filePath), fileGlob));
+	if (!matchingGlob || !options.yamlSchema[matchingGlob]) return null;
+	const yamlSchema = options.yamlSchema[matchingGlob];
+	if (!yamlSchema.include) {
+		logger.error("No include property found in YAML schema");
+		return exitSync(1);
+	}
+	return yamlSchema;
 }
+//#endregion
+export { validateYamlSchema };
+
+//# sourceMappingURL=utils.js.map

package/dist/formats/yaml/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../../src/formats/yaml/utils.ts"],"sourcesContent":["import { AdditionalOptions, YamlSchema } from '../../types/index.js';\nimport { exitSync } from '../../console/logging.js';\nimport { logger } from '../../console/logger.js';\nimport micromatch from 'micromatch';\nconst { isMatch } = micromatch;\nimport path from 'path';\n\nexport function validateYamlSchema(\n  options: AdditionalOptions,\n  filePath: string\n): YamlSchema | null {\n  if (!options.yamlSchema) {\n    return null;\n  }\n  // Check if the file matches any of the yaml schema globs\n  const fileGlobs = Object.keys(options.yamlSchema);\n  const matchingGlob = fileGlobs.find((fileGlob) =>\n    isMatch(path.relative(process.cwd(), filePath), fileGlob)\n  );\n  if (!matchingGlob || !options.yamlSchema[matchingGlob]) {\n    return null;\n  }\n\n  // Validate includes\n  const yamlSchema = options.yamlSchema[matchingGlob];\n  if (!yamlSchema.include) {\n    logger.error('No include property found in YAML schema');\n    return exitSync(1);\n  }\n  return yamlSchema;\n}\n"],"mappings":";;;;;AAIA,MAAM,EAAE,YAAY;AAGpB,SAAgB,mBACd,SACA,UACmB;AACnB,KAAI,CAAC,QAAQ,WACX,QAAO;CAIT,MAAM,eADY,OAAO,KAAK,QAAQ,WACR,CAAC,MAAM,aACnC,QAAQ,KAAK,SAAS,QAAQ,KAAK,EAAE,SAAS,EAAE,SAAS,CAC1D;AACD,KAAI,CAAC,gBAAgB,CAAC,QAAQ,WAAW,cACvC,QAAO;CAIT,MAAM,aAAa,QAAQ,WAAW;AACtC,KAAI,CAAC,WAAW,SAAS;AACvB,SAAO,MAAM,2CAA2C;AACxD,SAAO,SAAS,EAAE;;AAEpB,QAAO"}

package/dist/fs/clearLocaleDirs.js

@@ -1,126 +1,94 @@
-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';
+import { logger } from "../console/logger.js";
+import path from "node:path";
+import fg from "fast-glob";
+import micromatch from "micromatch";
+import fs from "fs/promises";
+//#region src/fs/clearLocaleDirs.ts
 /**
- * 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"
- */
+* 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;
+	const localeDirs = /* @__PURE__ */ new Set();
+	const localeSet = new Set(locales);
+	for (const filePath of filePaths) {
+		const parts = filePath.split(path.sep);
+		for (let i = 0; i < parts.length - 1; i++) {
+			const segment = parts[i];
+			if (localeSet.has(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,
-    });
+	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));
+	const allFiles = await getAllFiles(dirPath);
+	const absoluteCwd = path.resolve(cwd);
+	const filesToKeep = micromatch(allFiles, excludePatterns.map((p) => {
+		return (path.isAbsolute(p) ? p : path.join(absoluteCwd, p)).replace(/\[locale\]/g, currentLocale).replace(/\[locales\]/g, currentLocale);
+	}), { 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}`);
-            }
-        }
-    }
+* 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())
+*/
+async function clearLocaleDirs(filePaths, locales, excludePatterns, cwd = process.cwd()) {
+	const localeDirs = extractLocaleDirectories(filePaths, locales);
+	for (const dir of localeDirs) try {
+		await fs.stat(dir);
+		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);
+		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}`);
+		}
+		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
- */
+* 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 {
-        // Ignore errors - directory might not exist or might not be empty
-    }
+	try {
+		const entries = await fs.readdir(dirPath, { withFileTypes: true });
+		for (const entry of entries) if (entry.isDirectory()) await cleanupEmptyDirs(path.join(dirPath, entry.name));
+		if ((await fs.readdir(dirPath)).length === 0) await fs.rmdir(dirPath);
+	} catch {}
 }
+//#endregion
+export { clearLocaleDirs };
+
+//# sourceMappingURL=clearLocaleDirs.js.map

package/dist/fs/clearLocaleDirs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clearLocaleDirs.js","names":[],"sources":["../../src/fs/clearLocaleDirs.ts"],"sourcesContent":["import fs from 'fs/promises';\nimport path from 'node:path';\nimport { logger } from '../console/logger.js';\nimport fg from 'fast-glob';\nimport micromatch from 'micromatch';\n\n/**\n * Extracts locale directories from translated file paths.\n * Groups files by their immediate parent containing a locale code.\n * For example: \"snippets/es/api-test/file.mdx\" -> \"snippets/es\"\n */\nfunction extractLocaleDirectories(\n  filePaths: Set<string>,\n  locales: string[]\n): Set<string> {\n  const localeDirs = new Set<string>();\n  const localeSet = new Set(locales);\n\n  for (const filePath of filePaths) {\n    const parts = filePath.split(path.sep);\n\n    // Find directory segments that match the provided locales\n    for (let i = 0; i < parts.length - 1; i++) {\n      const segment = parts[i];\n      if (localeSet.has(segment)) {\n        // Found a locale directory, capture up to and including this segment\n        const localeDir = parts.slice(0, i + 1).join(path.sep);\n        localeDirs.add(localeDir);\n        break;\n      }\n    }\n  }\n\n  return localeDirs;\n}\n\nasync function getAllFiles(dirPath: string): Promise<string[]> {\n  return await fg(path.join(dirPath, '**/*'), {\n    absolute: true,\n    onlyFiles: true,\n  });\n}\n\nasync function getFilesToDelete(\n  dirPath: string,\n  excludePatterns: string[],\n  currentLocale: string,\n  cwd: string\n): Promise<string[]> {\n  const allFiles = await getAllFiles(dirPath);\n\n  const absoluteCwd = path.resolve(cwd);\n  const expandedExcludePatterns = excludePatterns.map((p) => {\n    const resolvedPattern = path.isAbsolute(p) ? p : path.join(absoluteCwd, p);\n    return resolvedPattern\n      .replace(/\\[locale\\]/g, currentLocale)\n      .replace(/\\[locales\\]/g, currentLocale);\n  });\n\n  const filesToKeep = micromatch(allFiles, expandedExcludePatterns, {\n    dot: true,\n  });\n\n  const filesToKeepSet = new Set(filesToKeep);\n  return allFiles.filter((file) => !filesToKeepSet.has(file));\n}\n\n/**\n * Clears translated files before writing new translations\n * @param filePaths - Set of translated file paths to clear\n * @param locales - Array of locale codes to match against\n * @param excludePatterns - Optional array of glob patterns to exclude from clearing (supports [locale] and [locales])\n * @param cwd - Current working directory for resolving relative exclude patterns (defaults to process.cwd())\n */\nexport async function clearLocaleDirs(\n  filePaths: Set<string>,\n  locales: string[],\n  excludePatterns?: string[],\n  cwd: string = process.cwd()\n): Promise<void> {\n  // Extract locale directories\n  const localeDirs = extractLocaleDirectories(filePaths, locales);\n\n  for (const dir of localeDirs) {\n    try {\n      await fs.stat(dir);\n\n      // Extract locale from directory path\n      const dirParts = dir.split(path.sep);\n      const locale = locales.find((loc) => dirParts.includes(loc));\n\n      if (!locale) {\n        continue;\n      }\n\n      if (!excludePatterns?.length) {\n        await fs.rm(dir, { recursive: true, force: true });\n        logger.success(`Cleared locale directory: ${dir}`);\n        continue;\n      }\n\n      const filesToDelete = await getFilesToDelete(\n        dir,\n        excludePatterns,\n        locale,\n        cwd\n      );\n\n      // Get all files for count comparison\n      const allFiles = await getAllFiles(dir);\n\n      for (const file of filesToDelete) {\n        try {\n          await fs.unlink(file);\n        } catch (error) {\n          if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {\n            logger.warn(`Failed to delete file ${file}: ${error}`);\n          }\n        }\n      }\n\n      // Clean up empty directories\n      await cleanupEmptyDirs(dir);\n\n      const excludedCount = allFiles.length - filesToDelete.length;\n      if (excludedCount > 0) {\n        logger.success(\n          `Cleared locale directory: ${dir} (excluded ${excludedCount} file${excludedCount > 1 ? 's' : ''})`\n        );\n      } else {\n        logger.success(`Cleared locale directory: ${dir}`);\n      }\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {\n        logger.warn(`Failed to clear locale directory ${dir}: ${error}`);\n      }\n    }\n  }\n}\n\n/**\n * Recursively removes empty directories\n * @param dirPath - The directory to clean up\n */\nasync function cleanupEmptyDirs(dirPath: string): Promise<void> {\n  try {\n    const entries = await fs.readdir(dirPath, { withFileTypes: true });\n\n    // Recursively clean subdirectories first\n    for (const entry of entries) {\n      if (entry.isDirectory()) {\n        await cleanupEmptyDirs(path.join(dirPath, entry.name));\n      }\n    }\n\n    // Check if directory is now empty\n    const remainingEntries = await fs.readdir(dirPath);\n    if (remainingEntries.length === 0) {\n      await fs.rmdir(dirPath);\n    }\n  } catch {\n    // Ignore errors - directory might not exist or might not be empty\n  }\n}\n"],"mappings":";;;;;;;;;;;AAWA,SAAS,yBACP,WACA,SACa;CACb,MAAM,6BAAa,IAAI,KAAa;CACpC,MAAM,YAAY,IAAI,IAAI,QAAQ;AAElC,MAAK,MAAM,YAAY,WAAW;EAChC,MAAM,QAAQ,SAAS,MAAM,KAAK,IAAI;AAGtC,OAAK,IAAI,IAAI,GAAG,IAAI,MAAM,SAAS,GAAG,KAAK;GACzC,MAAM,UAAU,MAAM;AACtB,OAAI,UAAU,IAAI,QAAQ,EAAE;IAE1B,MAAM,YAAY,MAAM,MAAM,GAAG,IAAI,EAAE,CAAC,KAAK,KAAK,IAAI;AACtD,eAAW,IAAI,UAAU;AACzB;;;;AAKN,QAAO;;AAGT,eAAe,YAAY,SAAoC;AAC7D,QAAO,MAAM,GAAG,KAAK,KAAK,SAAS,OAAO,EAAE;EAC1C,UAAU;EACV,WAAW;EACZ,CAAC;;AAGJ,eAAe,iBACb,SACA,iBACA,eACA,KACmB;CACnB,MAAM,WAAW,MAAM,YAAY,QAAQ;CAE3C,MAAM,cAAc,KAAK,QAAQ,IAAI;CAQrC,MAAM,cAAc,WAAW,UAPC,gBAAgB,KAAK,MAAM;AAEzD,UADwB,KAAK,WAAW,EAAE,GAAG,IAAI,KAAK,KAAK,aAAa,EAAE,EAEvE,QAAQ,eAAe,cAAc,CACrC,QAAQ,gBAAgB,cAAc;GAGqB,EAAE,EAChE,KAAK,MACN,CAAC;CAEF,MAAM,iBAAiB,IAAI,IAAI,YAAY;AAC3C,QAAO,SAAS,QAAQ,SAAS,CAAC,eAAe,IAAI,KAAK,CAAC;;;;;;;;;AAU7D,eAAsB,gBACpB,WACA,SACA,iBACA,MAAc,QAAQ,KAAK,EACZ;CAEf,MAAM,aAAa,yBAAyB,WAAW,QAAQ;AAE/D,MAAK,MAAM,OAAO,WAChB,KAAI;AACF,QAAM,GAAG,KAAK,IAAI;EAGlB,MAAM,WAAW,IAAI,MAAM,KAAK,IAAI;EACpC,MAAM,SAAS,QAAQ,MAAM,QAAQ,SAAS,SAAS,IAAI,CAAC;AAE5D,MAAI,CAAC,OACH;AAGF,MAAI,CAAC,iBAAiB,QAAQ;AAC5B,SAAM,GAAG,GAAG,KAAK;IAAE,WAAW;IAAM,OAAO;IAAM,CAAC;AAClD,UAAO,QAAQ,6BAA6B,MAAM;AAClD;;EAGF,MAAM,gBAAgB,MAAM,iBAC1B,KACA,iBACA,QACA,IACD;EAGD,MAAM,WAAW,MAAM,YAAY,IAAI;AAEvC,OAAK,MAAM,QAAQ,cACjB,KAAI;AACF,SAAM,GAAG,OAAO,KAAK;WACd,OAAO;AACd,OAAK,MAAgC,SAAS,SAC5C,QAAO,KAAK,yBAAyB,KAAK,IAAI,QAAQ;;AAM5D,QAAM,iBAAiB,IAAI;EAE3B,MAAM,gBAAgB,SAAS,SAAS,cAAc;AACtD,MAAI,gBAAgB,EAClB,QAAO,QACL,6BAA6B,IAAI,aAAa,cAAc,OAAO,gBAAgB,IAAI,MAAM,GAAG,GACjG;MAED,QAAO,QAAQ,6BAA6B,MAAM;UAE7C,OAAO;AACd,MAAK,MAAgC,SAAS,SAC5C,QAAO,KAAK,oCAAoC,IAAI,IAAI,QAAQ;;;;;;;AAUxE,eAAe,iBAAiB,SAAgC;AAC9D,KAAI;EACF,MAAM,UAAU,MAAM,GAAG,QAAQ,SAAS,EAAE,eAAe,MAAM,CAAC;AAGlE,OAAK,MAAM,SAAS,QAClB,KAAI,MAAM,aAAa,CACrB,OAAM,iBAAiB,KAAK,KAAK,SAAS,MAAM,KAAK,CAAC;AAM1D,OAAI,MAD2B,GAAG,QAAQ,QAAQ,EAC7B,WAAW,EAC9B,OAAM,GAAG,MAAM,QAAQ;SAEnB"}