@lang-tag/cli 0.15.0 → 0.17.0

package/algorithms/index.js

@@ -1,8 +1,20 @@
-import { T as TranslationsCollector, e as $LT_RemoveFile, c as $LT_EnsureDirectoryExists } from "../namespace-collector-DCruv_PK.js";
-import { N } from "../namespace-collector-DCruv_PK.js";
-import path, { resolve, sep } from "pathe";
-import process__default from "node:process";
 import * as caseLib from "case";
+import process__default from "node:process";
+import { rm, mkdir } from "fs/promises";
+import path, { resolve, sep, join } from "pathe";
+import { T as TranslationsCollector } from "../chunks/namespace-collector.js";
+import { N } from "../chunks/namespace-collector.js";
+import micromatch from "micromatch";
+function applyCaseTransform(str, caseType) {
+  if (caseType === "no") {
+    return str;
+  }
+  const caseFunction = caseLib[caseType];
+  if (typeof caseFunction === "function") {
+    return caseFunction(str);
+  }
+  return str;
+}
 class DictionaryCollector extends TranslationsCollector {
   constructor(options = {
     appendNamespaceToPath: false
@@ -36,12 +48,15 @@ class DictionaryCollector extends TranslationsCollector {
   }
   async preWrite(clean) {
     this.clean = clean;
-    const baseDictionaryFile = path.join(this.config.localesDirectory, `${this.config.baseLanguageCode}.json`);
+    const baseDictionaryFile = path.join(
+      this.config.localesDirectory,
+      `${this.config.baseLanguageCode}.json`
+    );
     if (clean) {
       this.logger.info("Removing {file}", { file: baseDictionaryFile });
-      await $LT_RemoveFile(baseDictionaryFile);
+      await removeFile(baseDictionaryFile);
     }
-    await $LT_EnsureDirectoryExists(this.config.localesDirectory);
+    await ensureDirectoryExists(this.config.localesDirectory);
   }
   async resolveCollectionFilePath(baseLanguageCode) {
     return resolve(
@@ -52,16 +67,23 @@ class DictionaryCollector extends TranslationsCollector {
   }
   async onMissingCollection(baseLanguageCode) {
     if (!this.clean) {
-      this.logger.warn(`Original dictionary file "{namespace}.json" not found. A new one will be created.`, { namespace: baseLanguageCode });
+      this.logger.warn(
+        `Original dictionary file "{namespace}.json" not found. A new one will be created.`,
+        { namespace: baseLanguageCode }
+      );
     }
   }
   async postWrite(changedCollections) {
     if (!changedCollections?.length) {
-      this.logger.info("No changes were made based on the current configuration and files");
+      this.logger.info(
+        "No changes were made based on the current configuration and files"
+      );
       return;
     }
     if (changedCollections.length > 1) {
-      throw new Error("Should not write more than 1 collection! Only 1 base language dictionary expected!");
+      throw new Error(
+        "Should not write more than 1 collection! Only 1 base language dictionary expected!"
+      );
     }
     const dict = resolve(
       this.config.localesDirectory,
@@ -70,6 +92,21 @@ class DictionaryCollector extends TranslationsCollector {
     this.logger.success("Updated dictionary {dict}", { dict });
   }
 }
+async function ensureDirectoryExists(filePath) {
+  try {
+    await mkdir(filePath, { recursive: true });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+async function removeFile(filePath) {
+  try {
+    await rm(filePath, { force: true });
+  } catch (error) {
+  }
+}
 const TRIGGER_NAME$2 = "path-based-config-generator";
 function pathBasedConfigGenerator(options = {}) {
   const {
@@ -116,15 +153,22 @@ function pathBasedConfigGenerator(options = {}) {
     if (hasPathRules) {
       pathSegments = applyPathRules(pathSegments, pathRules);
     } else {
-      pathSegments = applyStructuredIgnore(pathSegments, ignoreStructured);
+      pathSegments = applyStructuredIgnore(
+        pathSegments,
+        ignoreStructured
+      );
     }
     if (ignoreIncludesRootDirectories && langTagConfig.includes && pathSegments.length > 0) {
-      const extractedDirectories = extractRootDirectoriesFromIncludes(langTagConfig.includes);
+      const extractedDirectories = extractRootDirectoriesFromIncludes(
+        langTagConfig.includes
+      );
       if (extractedDirectories.includes(pathSegments[0])) {
         pathSegments = pathSegments.slice(1);
       }
     }
-    pathSegments = pathSegments.filter((seg) => !ignoreDirectories.includes(seg));
+    pathSegments = pathSegments.filter(
+      (seg) => !ignoreDirectories.includes(seg)
+    );
     let namespace;
     let path2;
     if (pathSegments.length >= 1) {
@@ -147,7 +191,9 @@ function pathBasedConfigGenerator(options = {}) {
     }
     if (path2 && pathCase) {
       const pathParts = path2.split(".");
-      const transformedParts = pathParts.map((part) => applyCaseTransform(part, pathCase));
+      const transformedParts = pathParts.map(
+        (part) => applyCaseTransform(part, pathCase)
+      );
       path2 = transformedParts.join(".");
     }
     const newConfig = event.config ? { ...event.config } : {};
@@ -306,7 +352,10 @@ function applyPathRules(segments, structure) {
           const remainingSegments = segments.slice(i + 1);
           const ruleWithoutRedirect = { ...rule };
           delete ruleWithoutRedirect[">>"];
-          const processedRemaining = applyPathRules(remainingSegments, ruleWithoutRedirect);
+          const processedRemaining = applyPathRules(
+            remainingSegments,
+            ruleWithoutRedirect
+          );
           deepestRedirect = {
             rule: redirectRule,
             remainingSegments: processedRemaining,
@@ -340,13 +389,6 @@ function applyPathRules(segments, structure) {
   }
   return result;
 }
-function applyCaseTransform(str, caseType) {
-  const caseFunction = caseLib[caseType];
-  if (typeof caseFunction === "function") {
-    return caseFunction(str);
-  }
-  return str;
-}
 function extractRootDirectoriesFromIncludes(includes) {
   const directories = /* @__PURE__ */ new Set();
   for (const pattern of includes) {
@@ -439,17 +481,367 @@ function prependNamespaceToPath(options = {}) {
     } else {
       newPath = actualNamespace;
     }
-    event.save({
-      ...currentConfig || {},
-      path: newPath,
-      namespace: void 0
-    }, TRIGGER_NAME);
+    event.save(
+      {
+        ...currentConfig || {},
+        path: newPath,
+        namespace: void 0
+      },
+      TRIGGER_NAME
+    );
+  };
+}
+function flexibleImportAlgorithm(options = {}) {
+  const {
+    variableName = {},
+    filePath = {},
+    include,
+    exclude = {},
+    configRemap
+  } = options;
+  const { packages: includePackages, namespaces: includeNamespaces } = include || {};
+  const {
+    packages: excludePackages = [],
+    namespaces: excludeNamespaces = []
+  } = exclude;
+  return (event) => {
+    const { exports, importManager, logger } = event;
+    for (const { packageJSON, exportData } of exports) {
+      const packageName = packageJSON.name || "unknown-package";
+      if (includePackages && !matchesAnyPattern(packageName, includePackages)) {
+        logger.debug(
+          `Skipping package not in include list: ${packageName}`
+        );
+        continue;
+      }
+      if (matchesAnyPattern(packageName, excludePackages)) {
+        logger.debug(`Skipping excluded package: ${packageName}`);
+        continue;
+      }
+      logger.debug(`Processing library: ${packageName}`);
+      for (const file of exportData.files) {
+        const originalFileName = file.relativeFilePath;
+        const targetFilePath = generateFilePath(
+          packageName,
+          originalFileName,
+          filePath
+        );
+        for (let i = 0; i < file.tags.length; i++) {
+          const tag = file.tags[i];
+          const tagNamespace = tag.config?.namespace;
+          if (includeNamespaces && tagNamespace && !matchesAnyPattern(tagNamespace, includeNamespaces)) {
+            logger.debug(
+              `Skipping namespace not in include list: ${tagNamespace}`
+            );
+            continue;
+          }
+          if (tagNamespace && matchesAnyPattern(tagNamespace, excludeNamespaces)) {
+            logger.debug(
+              `Skipping excluded namespace: ${tagNamespace}`
+            );
+            continue;
+          }
+          const finalVariableName = generateVariableName(
+            tag.variableName,
+            packageName,
+            originalFileName,
+            i,
+            variableName,
+            tag
+          );
+          if (finalVariableName === null) {
+            logger.debug(
+              `Skipping tag without variableName in ${join(packageName, originalFileName)}`
+            );
+            continue;
+          }
+          let finalConfig = tag.config;
+          if (configRemap) {
+            const remappedConfig = configRemap(tag.config, {
+              packageName,
+              fileName: originalFileName,
+              variableName: finalVariableName,
+              tagIndex: i
+            });
+            if (remappedConfig === null) {
+              logger.debug(
+                `Removing config due to configRemap returning null in ${join(packageName, originalFileName)}`
+              );
+              finalConfig = null;
+            } else {
+              finalConfig = remappedConfig;
+            }
+          }
+          importManager.importTag(targetFilePath, {
+            variableName: finalVariableName,
+            translations: tag.translations,
+            config: finalConfig
+          });
+          logger.debug(
+            `Imported: ${finalVariableName} -> ${targetFilePath}`
+          );
+        }
+      }
+    }
+  };
+}
+function sanitizeVariableName(name) {
+  let sanitized = name.replace(/[^a-zA-Z0-9_$]/g, "$");
+  if (/^[0-9]/.test(sanitized)) {
+    sanitized = "$" + sanitized;
+  }
+  if (sanitized === "") {
+    sanitized = "$";
+  }
+  return sanitized;
+}
+function applyCaseTransformToPath(filePath, caseType) {
+  if (typeof caseType === "string") {
+    const segments = filePath.split("/");
+    const fileName = segments[segments.length - 1];
+    const directorySegments = segments.slice(0, -1);
+    const transformedDirectories = directorySegments.map(
+      (dir) => applyCaseTransform(dir, caseType)
+    );
+    const transformedFileName = applyCaseTransformToFileName(
+      fileName,
+      caseType
+    );
+    if (transformedDirectories.length === 0) {
+      return transformedFileName;
+    }
+    return [...transformedDirectories, transformedFileName].join("/");
+  }
+  if (typeof caseType === "object") {
+    const { directories = "no", files = "no" } = caseType;
+    const segments = filePath.split("/");
+    const fileName = segments[segments.length - 1];
+    const directorySegments = segments.slice(0, -1);
+    const transformedDirectories = directorySegments.map(
+      (dir) => applyCaseTransform(dir, directories)
+    );
+    const transformedFileName = applyCaseTransformToFileName(
+      fileName,
+      files
+    );
+    if (transformedDirectories.length === 0) {
+      return transformedFileName;
+    }
+    return [...transformedDirectories, transformedFileName].join("/");
+  }
+  return filePath;
+}
+function normalizePackageName(packageName, scopedPackageHandling = "replace", context = "variableName") {
+  switch (scopedPackageHandling) {
+    case "remove-scope":
+      let result = packageName.replace(/^@[^/]+\//, "");
+      if (context === "variableName") {
+        result = result.replace(/[^a-zA-Z0-9_$]/g, "_");
+      }
+      return result;
+    case "replace":
+    default:
+      let normalized = packageName.replace(/@/g, "").replace(/\//g, context === "variableName" ? "_" : "-");
+      if (context === "variableName") {
+        normalized = normalized.replace(/[^a-zA-Z0-9_$]/g, "_");
+      }
+      return normalized;
+  }
+}
+function generateVariableName(originalVariableName, packageName, fileName, index, options, tag) {
+  const {
+    prefixWithPackageName = false,
+    scopedPackageHandling = "replace",
+    case: caseType = "no",
+    sanitizeVariableName: shouldSanitize = true,
+    handleMissingVariableName = "auto-generate",
+    customVariableName
+  } = options;
+  if (customVariableName) {
+    const customName = customVariableName({
+      packageName,
+      fileName,
+      originalVariableName,
+      tagIndex: index,
+      tag
+    });
+    if (customName !== null) {
+      originalVariableName = customName;
+    }
+  }
+  if (!originalVariableName) {
+    switch (handleMissingVariableName) {
+      case "skip":
+        return null;
+      case "auto-generate":
+        originalVariableName = `translations${index + 1}`;
+        break;
+      default:
+        if (typeof handleMissingVariableName === "function") {
+          originalVariableName = handleMissingVariableName(
+            {},
+            packageName,
+            fileName,
+            index
+          );
+        } else {
+          return null;
+        }
+    }
+  }
+  let finalName = originalVariableName;
+  if (prefixWithPackageName) {
+    const normalizedPackageName = normalizePackageName(
+      packageName,
+      scopedPackageHandling,
+      "variableName"
+    );
+    finalName = `${normalizedPackageName}_${originalVariableName}`;
+  }
+  const transformedName = applyCaseTransform(finalName, caseType);
+  return shouldSanitize ? sanitizeVariableName(transformedName) : transformedName;
+}
+function generateFilePath(packageName, originalFileName, options) {
+  const {
+    groupByPackage = false,
+    includePackageInPath = false,
+    scopedPackageHandling = "replace",
+    case: caseType = "no"
+  } = options;
+  if (groupByPackage) {
+    const normalizedPackageName = normalizePackageName(
+      packageName,
+      scopedPackageHandling,
+      "filePath"
+    );
+    const fileName = `${normalizedPackageName}.ts`;
+    return applyCaseTransformToFileName(
+      fileName,
+      typeof caseType === "string" ? caseType : caseType.files || "no"
+    );
+  } else if (includePackageInPath) {
+    const normalizedPackageName = normalizePackageName(
+      packageName,
+      scopedPackageHandling,
+      "filePath"
+    );
+    if (typeof caseType === "string") {
+      const transformedPackageName = applyCaseTransform(
+        normalizedPackageName,
+        caseType
+      );
+      const transformedFilePath = applyCaseTransformToPath(
+        originalFileName,
+        caseType
+      );
+      return join(transformedPackageName, transformedFilePath);
+    } else {
+      const transformedPackageName = applyCaseTransform(
+        normalizedPackageName,
+        caseType.directories || "no"
+      );
+      const transformedFilePath = applyCaseTransformToPath(
+        originalFileName,
+        caseType
+      );
+      return join(transformedPackageName, transformedFilePath);
+    }
+  } else {
+    return applyCaseTransformToPath(originalFileName, caseType);
+  }
+}
+function applyCaseTransformToFileName(fileName, caseType) {
+  if (caseType === "no") {
+    return fileName;
+  }
+  const lastDotIndex = fileName.lastIndexOf(".");
+  if (lastDotIndex === -1) {
+    return applyCaseTransform(fileName, caseType);
+  }
+  const nameWithoutExt = fileName.substring(0, lastDotIndex);
+  const extension = fileName.substring(lastDotIndex);
+  const transformedName = applyCaseTransform(nameWithoutExt, caseType);
+  return transformedName + extension;
+}
+function matchesAnyPattern(str, patterns) {
+  return micromatch.isMatch(str, patterns);
+}
+function simpleMappingImportAlgorithm(options) {
+  const { mappings, configRemap } = options;
+  const packageMap = /* @__PURE__ */ new Map();
+  const fileMap = /* @__PURE__ */ new Map();
+  for (const mapping of mappings) {
+    packageMap.set(mapping.packageName, mapping);
+    const files = /* @__PURE__ */ new Map();
+    for (const file of mapping.files) {
+      files.set(file.sourceFile, file);
+    }
+    fileMap.set(mapping.packageName, files);
+  }
+  return (event) => {
+    const { exports, importManager, logger } = event;
+    for (const { packageJSON, exportData } of exports) {
+      const packageName = packageJSON.name || "unknown-package";
+      const packageMapping = packageMap.get(packageName);
+      if (!packageMapping) {
+        logger.debug(`Skipping unmapped package: ${packageName}`);
+        continue;
+      }
+      logger.debug(`Processing mapped package: ${packageName}`);
+      for (const file of exportData.files) {
+        const sourceFile = file.relativeFilePath;
+        const packageFiles = fileMap.get(packageName);
+        if (!packageFiles) continue;
+        const fileMapping = packageFiles.get(sourceFile);
+        if (!fileMapping) {
+          logger.debug(
+            `Skipping unmapped file: ${packageName}/${sourceFile}`
+          );
+          continue;
+        }
+        logger.debug(
+          `Processing mapped file: ${packageName}/${sourceFile} -> ${fileMapping.targetFile}`
+        );
+        for (const tag of file.tags) {
+          const originalVariableName = tag.variableName;
+          if (!originalVariableName || !(originalVariableName in fileMapping.variables)) {
+            logger.debug(
+              `Skipping unmapped variable: ${originalVariableName} in ${packageName}/${sourceFile}`
+            );
+            continue;
+          }
+          const newVariableName = fileMapping.variables[originalVariableName] || originalVariableName;
+          const targetFilePath = fileMapping.targetFile;
+          let finalConfig = tag.config;
+          if (configRemap) {
+            finalConfig = configRemap(tag.config, {
+              packageName,
+              sourceFile,
+              targetFile: targetFilePath,
+              variableName: newVariableName,
+              originalVariableName
+            });
+          }
+          importManager.importTag(targetFilePath, {
+            variableName: newVariableName,
+            translations: tag.translations,
+            config: finalConfig
+          });
+          logger.debug(
+            `Imported: ${originalVariableName} -> ${newVariableName} in ${targetFilePath}`
+          );
+        }
+      }
+    }
   };
 }
 export {
   DictionaryCollector,
   N as NamespaceCollector,
+  applyCaseTransform,
   configKeeper,
+  flexibleImportAlgorithm,
   pathBasedConfigGenerator,
-  prependNamespaceToPath
+  prependNamespaceToPath,
+  simpleMappingImportAlgorithm
 };

package/chunks/namespace-collector.cjs

@@ -0,0 +1,75 @@
+"use strict";
+const process = require("node:process");
+const promises = require("fs/promises");
+const path = require("pathe");
+class TranslationsCollector {
+  config;
+  logger;
+}
+class NamespaceCollector extends TranslationsCollector {
+  clean;
+  languageDirectory;
+  aggregateCollection(namespace) {
+    return namespace;
+  }
+  transformTag(tag) {
+    return tag;
+  }
+  async preWrite(clean) {
+    this.clean = clean;
+    this.languageDirectory = path.join(
+      this.config.localesDirectory,
+      this.config.baseLanguageCode
+    );
+    if (clean) {
+      this.logger.info("Cleaning output directory...");
+      await removeDirectory(this.languageDirectory);
+    }
+    await ensureDirectoryExists(this.languageDirectory);
+  }
+  async resolveCollectionFilePath(collectionName) {
+    return path.resolve(
+      process.cwd(),
+      this.languageDirectory,
+      collectionName + ".json"
+    );
+  }
+  async onMissingCollection(collectionName) {
+    if (!this.clean) {
+      this.logger.warn(
+        `Original namespace file "{namespace}.json" not found. A new one will be created.`,
+        { namespace: collectionName }
+      );
+    }
+  }
+  async postWrite(changedCollections) {
+    if (!changedCollections?.length) {
+      this.logger.info(
+        "No changes were made based on the current configuration and files"
+      );
+      return;
+    }
+    const n = changedCollections.map((n2) => `"${n2}.json"`).join(", ");
+    this.logger.success("Updated namespaces {outputDir} ({namespaces})", {
+      outputDir: this.config.localesDirectory,
+      namespaces: n
+    });
+  }
+}
+async function ensureDirectoryExists(filePath) {
+  try {
+    await promises.mkdir(filePath, { recursive: true });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+async function removeDirectory(dirPath) {
+  try {
+    await promises.rm(dirPath, { recursive: true, force: true });
+  } catch (error) {
+  }
+}
+exports.NamespaceCollector = NamespaceCollector;
+exports.TranslationsCollector = TranslationsCollector;

package/chunks/namespace-collector.js

@@ -0,0 +1,76 @@
+import process__default from "node:process";
+import { rm, mkdir } from "fs/promises";
+import path, { resolve } from "pathe";
+class TranslationsCollector {
+  config;
+  logger;
+}
+class NamespaceCollector extends TranslationsCollector {
+  clean;
+  languageDirectory;
+  aggregateCollection(namespace) {
+    return namespace;
+  }
+  transformTag(tag) {
+    return tag;
+  }
+  async preWrite(clean) {
+    this.clean = clean;
+    this.languageDirectory = path.join(
+      this.config.localesDirectory,
+      this.config.baseLanguageCode
+    );
+    if (clean) {
+      this.logger.info("Cleaning output directory...");
+      await removeDirectory(this.languageDirectory);
+    }
+    await ensureDirectoryExists(this.languageDirectory);
+  }
+  async resolveCollectionFilePath(collectionName) {
+    return resolve(
+      process__default.cwd(),
+      this.languageDirectory,
+      collectionName + ".json"
+    );
+  }
+  async onMissingCollection(collectionName) {
+    if (!this.clean) {
+      this.logger.warn(
+        `Original namespace file "{namespace}.json" not found. A new one will be created.`,
+        { namespace: collectionName }
+      );
+    }
+  }
+  async postWrite(changedCollections) {
+    if (!changedCollections?.length) {
+      this.logger.info(
+        "No changes were made based on the current configuration and files"
+      );
+      return;
+    }
+    const n = changedCollections.map((n2) => `"${n2}.json"`).join(", ");
+    this.logger.success("Updated namespaces {outputDir} ({namespaces})", {
+      outputDir: this.config.localesDirectory,
+      namespaces: n
+    });
+  }
+}
+async function ensureDirectoryExists(filePath) {
+  try {
+    await mkdir(filePath, { recursive: true });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+async function removeDirectory(dirPath) {
+  try {
+    await rm(dirPath, { recursive: true, force: true });
+  } catch (error) {
+  }
+}
+export {
+  NamespaceCollector as N,
+  TranslationsCollector as T
+};