@lang-tag/cli 0.16.0 → 0.18.0

package/algorithms/index.cjs

@@ -1,9 +1,39 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const flexibleImportAlgorithm = require("../flexible-import-algorithm-Fa-l4jWj.cjs");
-const path = require("pathe");
+const caseLib = require("case");
 const process = require("node:process");
-class DictionaryCollector extends flexibleImportAlgorithm.TranslationsCollector {
+const promises = require("fs/promises");
+const path = require("pathe");
+const namespaceCollector = require("../chunks/namespace-collector.cjs");
+const micromatch = require("micromatch");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const caseLib__namespace = /* @__PURE__ */ _interopNamespaceDefault(caseLib);
+function applyCaseTransform(str, caseType) {
+  if (caseType === "no") {
+    return str;
+  }
+  const caseFunction = caseLib__namespace[caseType];
+  if (typeof caseFunction === "function") {
+    return caseFunction(str);
+  }
+  return str;
+}
+class DictionaryCollector extends namespaceCollector.TranslationsCollector {
   constructor(options = {
     appendNamespaceToPath: false
   }) {
@@ -36,12 +66,15 @@ class DictionaryCollector extends flexibleImportAlgorithm.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 flexibleImportAlgorithm.$LT_RemoveFile(baseDictionaryFile);
+      await removeFile(baseDictionaryFile);
     }
-    await flexibleImportAlgorithm.$LT_EnsureDirectoryExists(this.config.localesDirectory);
+    await ensureDirectoryExists(this.config.localesDirectory);
   }
   async resolveCollectionFilePath(baseLanguageCode) {
     return path.resolve(
@@ -52,16 +85,23 @@ class DictionaryCollector extends flexibleImportAlgorithm.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 = path.resolve(
       this.config.localesDirectory,
@@ -70,6 +110,21 @@ class DictionaryCollector extends flexibleImportAlgorithm.TranslationsCollector
     this.logger.success("Updated dictionary {dict}", { dict });
   }
 }
+async function ensureDirectoryExists(filePath) {
+  try {
+    await promises.mkdir(filePath, { recursive: true });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+async function removeFile(filePath) {
+  try {
+    await promises.rm(filePath, { force: true });
+  } catch (error) {
+  }
+}
 const TRIGGER_NAME$2 = "path-based-config-generator";
 function pathBasedConfigGenerator(options = {}) {
   const {
@@ -116,15 +171,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 path$1;
     if (pathSegments.length >= 1) {
@@ -142,12 +204,14 @@ function pathBasedConfigGenerator(options = {}) {
         namespace = namespace.toLowerCase();
       }
       if (namespaceCase) {
-        namespace = flexibleImportAlgorithm.applyCaseTransform(namespace, namespaceCase);
+        namespace = applyCaseTransform(namespace, namespaceCase);
       }
     }
     if (path$1 && pathCase) {
       const pathParts = path$1.split(".");
-      const transformedParts = pathParts.map((part) => flexibleImportAlgorithm.applyCaseTransform(part, pathCase));
+      const transformedParts = pathParts.map(
+        (part) => applyCaseTransform(part, pathCase)
+      );
       path$1 = transformedParts.join(".");
     }
     const newConfig = event.config ? { ...event.config } : {};
@@ -306,7 +370,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,
@@ -432,13 +499,291 @@ 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: exports2, importManager, logger } = event;
+    for (const { packageJSON, exportData } of exports2) {
+      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 ${path.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 ${path.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 path.join(transformedPackageName, transformedFilePath);
+    } else {
+      const transformedPackageName = applyCaseTransform(
+        normalizedPackageName,
+        caseType.directories || "no"
+      );
+      const transformedFilePath = applyCaseTransformToPath(
+        originalFileName,
+        caseType
+      );
+      return path.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();
@@ -467,14 +812,20 @@ function simpleMappingImportAlgorithm(options) {
         if (!packageFiles) continue;
         const fileMapping = packageFiles.get(sourceFile);
         if (!fileMapping) {
-          logger.debug(`Skipping unmapped file: ${packageName}/${sourceFile}`);
+          logger.debug(
+            `Skipping unmapped file: ${packageName}/${sourceFile}`
+          );
           continue;
         }
-        logger.debug(`Processing mapped file: ${packageName}/${sourceFile} -> ${fileMapping.targetFile}`);
+        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}`);
+            logger.debug(
+              `Skipping unmapped variable: ${originalVariableName} in ${packageName}/${sourceFile}`
+            );
             continue;
           }
           const newVariableName = fileMapping.variables[originalVariableName] || originalVariableName;
@@ -494,17 +845,19 @@ function simpleMappingImportAlgorithm(options) {
             translations: tag.translations,
             config: finalConfig
           });
-          logger.debug(`Imported: ${originalVariableName} -> ${newVariableName} in ${targetFilePath}`);
+          logger.debug(
+            `Imported: ${originalVariableName} -> ${newVariableName} in ${targetFilePath}`
+          );
         }
       }
     }
   };
 }
-exports.NamespaceCollector = flexibleImportAlgorithm.NamespaceCollector;
-exports.applyCaseTransform = flexibleImportAlgorithm.applyCaseTransform;
-exports.flexibleImportAlgorithm = flexibleImportAlgorithm.flexibleImportAlgorithm;
+exports.NamespaceCollector = namespaceCollector.NamespaceCollector;
 exports.DictionaryCollector = DictionaryCollector;
+exports.applyCaseTransform = applyCaseTransform;
 exports.configKeeper = configKeeper;
+exports.flexibleImportAlgorithm = flexibleImportAlgorithm;
 exports.pathBasedConfigGenerator = pathBasedConfigGenerator;
 exports.prependNamespaceToPath = prependNamespaceToPath;
 exports.simpleMappingImportAlgorithm = simpleMappingImportAlgorithm;

package/algorithms/index.d.ts

@@ -8,6 +8,6 @@
  * - Case Utils: Common case transformation utilities
  */
 export * from './case-utils';
-export * from './collector/index.ts';
-export * from './config-generation/index.ts';
-export * from './import/index.ts';
+export * from './collector/index';
+export * from './config-generation/index';
+export * from './import/index';