@lang-tag/cli 0.14.0 → 0.16.0

package/algorithms/index.cjs

@@ -1,25 +1,76 @@
 "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");
-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]
-        });
+const process = require("node:process");
+class DictionaryCollector extends flexibleImportAlgorithm.TranslationsCollector {
+  constructor(options = {
+    appendNamespaceToPath: false
+  }) {
+    super();
+    this.options = options;
+  }
+  clean;
+  aggregateCollection(namespace) {
+    return this.config.baseLanguageCode;
+  }
+  transformTag(tag) {
+    const originalPath = tag.parameterConfig.path;
+    let path2 = originalPath;
+    if (this.options.appendNamespaceToPath) {
+      path2 = tag.parameterConfig.namespace;
+      if (originalPath) {
+        path2 += ".";
+        path2 += originalPath;
       }
+      return {
+        ...tag,
+        parameterConfig: {
+          ...tag.parameterConfig,
+          namespace: void 0,
+          path: path2
+        }
+      };
+    }
+    return tag;
+  }
+  async preWrite(clean) {
+    this.clean = clean;
+    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 flexibleImportAlgorithm.$LT_EnsureDirectoryExists(this.config.localesDirectory);
+  }
+  async resolveCollectionFilePath(baseLanguageCode) {
+    return path.resolve(
+      process.cwd(),
+      this.config.localesDirectory,
+      baseLanguageCode + ".json"
+    );
+  }
+  async onMissingCollection(baseLanguageCode) {
+    if (!this.clean) {
+      this.logger.warn(`Original dictionary file "{namespace}.json" not found. A new one will be created.`, { namespace: baseLanguageCode });
     }
   }
-  n.default = e;
-  return Object.freeze(n);
+  async postWrite(changedCollections) {
+    if (!changedCollections?.length) {
+      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!");
+    }
+    const dict = path.resolve(
+      this.config.localesDirectory,
+      this.config.baseLanguageCode + ".json"
+    );
+    this.logger.success("Updated dictionary {dict}", { dict });
+  }
 }
-const caseLib__namespace = /* @__PURE__ */ _interopNamespaceDefault(caseLib);
-const TRIGGER_NAME$1 = "path-based-config-generator";
+const TRIGGER_NAME$2 = "path-based-config-generator";
 function pathBasedConfigGenerator(options = {}) {
   const {
     includeFileName = false,
@@ -91,12 +142,12 @@ function pathBasedConfigGenerator(options = {}) {
         namespace = namespace.toLowerCase();
       }
       if (namespaceCase) {
-        namespace = applyCaseTransform(namespace, namespaceCase);
+        namespace = flexibleImportAlgorithm.applyCaseTransform(namespace, namespaceCase);
       }
     }
     if (path$1 && pathCase) {
       const pathParts = path$1.split(".");
-      const transformedParts = pathParts.map((part) => applyCaseTransform(part, pathCase));
+      const transformedParts = pathParts.map((part) => flexibleImportAlgorithm.applyCaseTransform(part, pathCase));
       path$1 = transformedParts.join(".");
     }
     const newConfig = event.config ? { ...event.config } : {};
@@ -109,7 +160,7 @@ function pathBasedConfigGenerator(options = {}) {
           (key) => key !== "namespace" && key !== "path"
         );
         if (!hasOtherProperties) {
-          event.save(null, TRIGGER_NAME$1);
+          event.save(null, TRIGGER_NAME$2);
           return;
         } else {
           delete newConfig.namespace;
@@ -127,7 +178,7 @@ function pathBasedConfigGenerator(options = {}) {
       }
     }
     if (Object.keys(newConfig).length > 0) {
-      event.save(newConfig, TRIGGER_NAME$1);
+      event.save(newConfig, TRIGGER_NAME$2);
     }
   };
 }
@@ -289,13 +340,6 @@ function applyPathRules(segments, structure) {
   }
   return result;
 }
-function applyCaseTransform(str, caseType) {
-  const caseFunction = caseLib__namespace[caseType];
-  if (typeof caseFunction === "function") {
-    return caseFunction(str);
-  }
-  return str;
-}
 function extractRootDirectoriesFromIncludes(includes) {
   const directories = /* @__PURE__ */ new Set();
   for (const pattern of includes) {
@@ -313,7 +357,7 @@ function extractRootDirectoriesFromIncludes(includes) {
   }
   return Array.from(directories);
 }
-const TRIGGER_NAME = "config-keeper";
+const TRIGGER_NAME$1 = "config-keeper";
 function configKeeper(options = {}) {
   const propertyName = options.propertyName ?? "keep";
   const keepPropertyAtEnd = options.keepPropertyAtEnd ?? true;
@@ -370,8 +414,97 @@ function configKeeper(options = {}) {
       delete finalConfig[propertyName];
     }
     finalConfig[propertyName] = keepMode;
-    event.save(finalConfig, TRIGGER_NAME);
+    event.save(finalConfig, TRIGGER_NAME$1);
+  };
+}
+const TRIGGER_NAME = "prepend-namespace-to-path";
+function prependNamespaceToPath(options = {}) {
+  return async (event) => {
+    const currentConfig = event.savedConfig;
+    const { namespace, path: path2 } = currentConfig || {};
+    const actualNamespace = namespace || event.langTagConfig.collect?.defaultNamespace;
+    if (!actualNamespace) {
+      return;
+    }
+    let newPath;
+    if (path2) {
+      newPath = `${actualNamespace}.${path2}`;
+    } else {
+      newPath = actualNamespace;
+    }
+    event.save({
+      ...currentConfig || {},
+      path: newPath,
+      namespace: void 0
+    }, TRIGGER_NAME);
+  };
+}
+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: exports2, importManager, logger } = event;
+    for (const { packageJSON, exportData } of exports2) {
+      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}`);
+        }
+      }
+    }
   };
 }
+exports.NamespaceCollector = flexibleImportAlgorithm.NamespaceCollector;
+exports.applyCaseTransform = flexibleImportAlgorithm.applyCaseTransform;
+exports.flexibleImportAlgorithm = flexibleImportAlgorithm.flexibleImportAlgorithm;
+exports.DictionaryCollector = DictionaryCollector;
 exports.configKeeper = configKeeper;
 exports.pathBasedConfigGenerator = pathBasedConfigGenerator;
+exports.prependNamespaceToPath = prependNamespaceToPath;
+exports.simpleMappingImportAlgorithm = simpleMappingImportAlgorithm;

package/algorithms/index.d.ts

@@ -1,7 +1,13 @@
 /**
- * Predefined algorithms for lang-tag-cli configuration.
+ * Algorithm modules for lang-tag-cli.
  *
- * These algorithms can be used in your lang-tag-cli config file
- * to customize how tags are processed during collection and regeneration.
+ * This module provides access to all available algorithms organized by category:
+ * - Collectors: Define how translation tags are organized into output files
+ * - Config Generation: Customize tag configuration generation
+ * - Import: Handle importing translation libraries
+ * - 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';

package/algorithms/index.js

@@ -1,6 +1,75 @@
-import { sep } from "pathe";
-import * as caseLib from "case";
-const TRIGGER_NAME$1 = "path-based-config-generator";
+import { T as TranslationsCollector, e as $LT_RemoveFile, c as $LT_EnsureDirectoryExists, g as applyCaseTransform } from "../flexible-import-algorithm-C-S1c742.js";
+import { N, f } from "../flexible-import-algorithm-C-S1c742.js";
+import path, { resolve, sep } from "pathe";
+import process__default from "node:process";
+class DictionaryCollector extends TranslationsCollector {
+  constructor(options = {
+    appendNamespaceToPath: false
+  }) {
+    super();
+    this.options = options;
+  }
+  clean;
+  aggregateCollection(namespace) {
+    return this.config.baseLanguageCode;
+  }
+  transformTag(tag) {
+    const originalPath = tag.parameterConfig.path;
+    let path2 = originalPath;
+    if (this.options.appendNamespaceToPath) {
+      path2 = tag.parameterConfig.namespace;
+      if (originalPath) {
+        path2 += ".";
+        path2 += originalPath;
+      }
+      return {
+        ...tag,
+        parameterConfig: {
+          ...tag.parameterConfig,
+          namespace: void 0,
+          path: path2
+        }
+      };
+    }
+    return tag;
+  }
+  async preWrite(clean) {
+    this.clean = clean;
+    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 $LT_EnsureDirectoryExists(this.config.localesDirectory);
+  }
+  async resolveCollectionFilePath(baseLanguageCode) {
+    return resolve(
+      process__default.cwd(),
+      this.config.localesDirectory,
+      baseLanguageCode + ".json"
+    );
+  }
+  async onMissingCollection(baseLanguageCode) {
+    if (!this.clean) {
+      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");
+      return;
+    }
+    if (changedCollections.length > 1) {
+      throw new Error("Should not write more than 1 collection! Only 1 base language dictionary expected!");
+    }
+    const dict = resolve(
+      this.config.localesDirectory,
+      this.config.baseLanguageCode + ".json"
+    );
+    this.logger.success("Updated dictionary {dict}", { dict });
+  }
+}
+const TRIGGER_NAME$2 = "path-based-config-generator";
 function pathBasedConfigGenerator(options = {}) {
   const {
     includeFileName = false,
@@ -56,13 +125,13 @@ function pathBasedConfigGenerator(options = {}) {
     }
     pathSegments = pathSegments.filter((seg) => !ignoreDirectories.includes(seg));
     let namespace;
-    let path;
+    let path2;
     if (pathSegments.length >= 1) {
       namespace = pathSegments[0];
       if (pathSegments.length > 1) {
-        path = pathSegments.slice(1).join(".");
+        path2 = pathSegments.slice(1).join(".");
       } else {
-        path = "";
+        path2 = "";
       }
     } else {
       namespace = actualFallbackNamespace;
@@ -75,22 +144,22 @@ function pathBasedConfigGenerator(options = {}) {
         namespace = applyCaseTransform(namespace, namespaceCase);
       }
     }
-    if (path && pathCase) {
-      const pathParts = path.split(".");
+    if (path2 && pathCase) {
+      const pathParts = path2.split(".");
       const transformedParts = pathParts.map((part) => applyCaseTransform(part, pathCase));
-      path = transformedParts.join(".");
+      path2 = transformedParts.join(".");
     }
     const newConfig = event.config ? { ...event.config } : {};
     if (clearOnDefaultNamespace && namespace === actualFallbackNamespace) {
-      if (path) {
-        newConfig.path = path;
+      if (path2) {
+        newConfig.path = path2;
         delete newConfig.namespace;
       } else {
         const hasOtherProperties = event.config && Object.keys(event.config).some(
           (key) => key !== "namespace" && key !== "path"
         );
         if (!hasOtherProperties) {
-          event.save(null, TRIGGER_NAME$1);
+          event.save(null, TRIGGER_NAME$2);
           return;
         } else {
           delete newConfig.namespace;
@@ -101,14 +170,14 @@ function pathBasedConfigGenerator(options = {}) {
       if (namespace) {
         newConfig.namespace = namespace;
       }
-      if (path) {
-        newConfig.path = path;
+      if (path2) {
+        newConfig.path = path2;
       } else {
         delete newConfig.path;
       }
     }
     if (Object.keys(newConfig).length > 0) {
-      event.save(newConfig, TRIGGER_NAME$1);
+      event.save(newConfig, TRIGGER_NAME$2);
     }
   };
 }
@@ -270,13 +339,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) {
@@ -286,7 +348,7 @@ function extractRootDirectoriesFromIncludes(includes) {
     const firstSegment = match[1];
     const groupMatch = firstSegment.match(/^[\(\[]([^\)\]]+)[\)\]]$/);
     if (groupMatch) {
-      const groupDirectories = groupMatch[1].split("|").map((f) => f.trim());
+      const groupDirectories = groupMatch[1].split("|").map((f2) => f2.trim());
       groupDirectories.forEach((directory) => directories.add(directory));
     } else {
       directories.add(firstSegment);
@@ -294,7 +356,7 @@ function extractRootDirectoriesFromIncludes(includes) {
   }
   return Array.from(directories);
 }
-const TRIGGER_NAME = "config-keeper";
+const TRIGGER_NAME$1 = "config-keeper";
 function configKeeper(options = {}) {
   const propertyName = options.propertyName ?? "keep";
   const keepPropertyAtEnd = options.keepPropertyAtEnd ?? true;
@@ -351,10 +413,99 @@ function configKeeper(options = {}) {
       delete finalConfig[propertyName];
     }
     finalConfig[propertyName] = keepMode;
-    event.save(finalConfig, TRIGGER_NAME);
+    event.save(finalConfig, TRIGGER_NAME$1);
+  };
+}
+const TRIGGER_NAME = "prepend-namespace-to-path";
+function prependNamespaceToPath(options = {}) {
+  return async (event) => {
+    const currentConfig = event.savedConfig;
+    const { namespace, path: path2 } = currentConfig || {};
+    const actualNamespace = namespace || event.langTagConfig.collect?.defaultNamespace;
+    if (!actualNamespace) {
+      return;
+    }
+    let newPath;
+    if (path2) {
+      newPath = `${actualNamespace}.${path2}`;
+    } else {
+      newPath = actualNamespace;
+    }
+    event.save({
+      ...currentConfig || {},
+      path: newPath,
+      namespace: void 0
+    }, TRIGGER_NAME);
+  };
+}
+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,
-  pathBasedConfigGenerator
+  f as flexibleImportAlgorithm,
+  pathBasedConfigGenerator,
+  prependNamespaceToPath,
+  simpleMappingImportAlgorithm
 };