@lang-tag/cli 0.13.1 → 0.15.0

package/algorithms/index.js

@@ -1,6 +1,76 @@
-import { sep } from "pathe";
+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";
-const TRIGGER_NAME$1 = "path-based-config-generator";
+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,11 +126,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 {
+        path2 = "";
       }
     } else {
       namespace = actualFallbackNamespace;
@@ -73,22 +145,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;
@@ -99,14 +171,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);
     }
   };
 }
@@ -144,11 +216,69 @@ function applyStructuredIgnore(segments, structure) {
   }
   return result;
 }
+function addPathPrefixAndSegments(result, pathPrefix, remainingSegments) {
+  if (pathPrefix && remainingSegments.length > 0) {
+    const cleanPrefix = pathPrefix.endsWith(".") ? pathPrefix.slice(0, -1) : pathPrefix;
+    result.push(cleanPrefix, ...remainingSegments);
+  } else if (pathPrefix && remainingSegments.length === 0) {
+    const cleanPrefix = pathPrefix.endsWith(".") ? pathPrefix.slice(0, -1) : pathPrefix;
+    result.push(cleanPrefix);
+  } else if (remainingSegments.length > 0) {
+    result.push(...remainingSegments);
+  }
+}
+function processNamespaceRedirect(redirectRule, remainingSegments, options) {
+  const result = [];
+  if (redirectRule === null || redirectRule === void 0) {
+    if (options?.currentSegment !== void 0) {
+      if (!options.ignoreSelf) {
+        result.push(options.renameTo || options.currentSegment);
+      }
+    }
+    result.push(...remainingSegments);
+  } else if (typeof redirectRule === "string") {
+    if (redirectRule === "") {
+      if (options?.currentSegment !== void 0) {
+        if (!options.ignoreSelf) {
+          result.push(options.renameTo || options.currentSegment);
+        }
+      }
+      result.push(...remainingSegments);
+    } else {
+      result.push(redirectRule);
+      result.push(...remainingSegments);
+    }
+  } else if (typeof redirectRule === "object" && redirectRule !== null) {
+    const namespace = redirectRule.namespace;
+    const pathPrefix = redirectRule.pathPrefix || "";
+    if (namespace === void 0 || namespace === null || namespace === "") {
+      if (options?.currentSegment !== void 0) {
+        if (!options.ignoreSelf) {
+          result.push(options.renameTo || options.currentSegment);
+        }
+      }
+      addPathPrefixAndSegments(result, pathPrefix, remainingSegments);
+    } else {
+      result.push(namespace);
+      addPathPrefixAndSegments(result, pathPrefix, remainingSegments);
+    }
+  }
+  return result;
+}
 function applyPathRules(segments, structure) {
   const result = [];
   let currentStructure = structure;
+  let deepestRedirect = null;
   for (let i = 0; i < segments.length; i++) {
     const segment = segments[i];
+    if (">>" in currentStructure && (!deepestRedirect || !deepestRedirect.context)) {
+      const redirectRule = currentStructure[">>"];
+      const remainingSegments = segments.slice(i);
+      deepestRedirect = {
+        rule: redirectRule,
+        remainingSegments
+      };
+    }
     if (segment in currentStructure) {
       const rule = currentStructure[segment];
       if (rule === true) {
@@ -171,6 +301,22 @@ function applyPathRules(segments, structure) {
       } else if (typeof rule === "object" && rule !== null) {
         const ignoreSelf = rule["_"] === false;
         const renameTo = rule[">"];
+        const redirectRule = rule[">>"];
+        if (">>" in rule) {
+          const remainingSegments = segments.slice(i + 1);
+          const ruleWithoutRedirect = { ...rule };
+          delete ruleWithoutRedirect[">>"];
+          const processedRemaining = applyPathRules(remainingSegments, ruleWithoutRedirect);
+          deepestRedirect = {
+            rule: redirectRule,
+            remainingSegments: processedRemaining,
+            context: {
+              currentSegment: segment,
+              renameTo,
+              ignoreSelf
+            }
+          };
+        }
         if (!ignoreSelf) {
           if (typeof renameTo === "string") {
             result.push(renameTo);
@@ -185,6 +331,13 @@ function applyPathRules(segments, structure) {
     result.push(segment);
     currentStructure = structure;
   }
+  if (deepestRedirect) {
+    return processNamespaceRedirect(
+      deepestRedirect.rule,
+      deepestRedirect.remainingSegments,
+      deepestRedirect.context
+    );
+  }
   return result;
 }
 function applyCaseTransform(str, caseType) {
@@ -211,7 +364,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;
@@ -268,10 +421,35 @@ 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);
   };
 }
 export {
+  DictionaryCollector,
+  N as NamespaceCollector,
   configKeeper,
-  pathBasedConfigGenerator
+  pathBasedConfigGenerator,
+  prependNamespaceToPath
 };

package/config.d.ts

@@ -1,5 +1,6 @@
 import { LangTagTranslationsConfig } from 'lang-tag';
 import { LangTagCLILogger } from './logger.ts';
+import { TranslationsCollector } from './algorithms/collector/type.ts';
 export interface LangTagCLIConfig {
     /**
      * Tag name used to mark translations in code.
@@ -17,11 +18,37 @@ export interface LangTagCLIConfig {
      */
     excludes: string[];
     /**
-     * Output directory for generated translation namespace files (e.g., common.json, errors.json).
-     * @default 'locales/en'
+     * Root directory for translation files.
+     * The actual file structure depends on the collector implementation used.
+     * @default 'locales'
+     * @example With baseLanguageCode='en' and localesDirectory='locales':
+     *   - NamespaceCollector (default): locales/en/common.json, locales/en/errors.json
+     *   - DictionaryCollector: locales/en.json (all translations in one file)
      */
-    outputDir: string;
+    localesDirectory: string;
+    /**
+     * The language in which translation values/messages are written in the codebase.
+     * This determines the source language for your translations.
+     * @default 'en'
+     * @example 'en' - Translation values are in English: lang({ helloWorld: 'Hello World' })
+     * @example 'pl' - Translation values are in Polish: lang({ helloWorld: 'Witaj Świecie' })
+     */
+    baseLanguageCode: string;
+    /**
+     * Indicates whether this configuration is for a translation library.
+     * If true, generates an exports file (`.lang-tag.exports.json`) instead of locale files.
+     * @default false
+     */
+    isLibrary: boolean;
     collect?: {
+        /**
+         * Translation collector that defines how translation tags are organized into output files.
+         * If not specified, NamespaceCollector is used by default.
+         * @default NamespaceCollector
+         * @example DictionaryCollector - All translations in single file per language
+         * @example NamespaceCollector - Separate files per namespace within language directory
+         */
+        collector?: TranslationsCollector;
         /**
          * @default 'common'
          */
@@ -50,50 +77,6 @@ export interface LangTagCLIConfig {
          */
         onCollectFinish?: (event: LangTagCLICollectFinishEvent) => void;
     };
-    import: {
-        /**
-         * Output directory for generated files containing imported library tags.
-         * @default 'src/lang-libraries'
-         */
-        dir: string;
-        /**
-         * The import statement used in generated library files to import the project's `lang` tag function.
-         * @default 'import { lang } from "@/my-lang-tag-path"'
-         */
-        tagImportPath: string;
-        /**
-         * A function to customize the generated file name and export name for imported library tags.
-         * Allows controlling how imported tags are organized and named within the generated files.
-         */
-        onImport: (params: LangTagCLIOnImportParams, actions: LangTagCLIOnImportActions) => void;
-        /**
-         * A function called after all lang-tags were imported
-         */
-        onImportFinish?: () => void;
-    };
-    /**
-     * Determines the position of the translation argument in the `lang()` function.
-     * If `1`, translations are in the first argument (`lang(translations, options)`).
-     * If `2`, translations are in the second argument (`lang(options, translations)`).
-     * @default 1
-     */
-    translationArgPosition: 1 | 2;
-    /**
-     * Primary language used for the library's translations.
-     * Affects default language settings when used in library mode.
-     * @default 'en'
-     */
-    language: string;
-    /**
-     * Indicates whether this configuration is for a translation library.
-     * If true, generates an exports file (`.lang-tag.exports.json`) instead of locale files.
-     * @default false
-     */
-    isLibrary: boolean;
-    /**
-     * Whether to flatten the translation keys. (Currently unused)
-     * @default false
-     */
     /**
      * A function called for each found lang tag before processing.
      * Allows dynamic modification of the tag's configuration (namespace, path, etc.)
@@ -123,6 +106,34 @@ export interface LangTagCLIConfig {
      * ```
      */
     onConfigGeneration: (event: LangTagCLIConfigGenerationEvent) => Promise<void>;
+    import: {
+        /**
+         * Output directory for generated files containing imported library tags.
+         * @default 'src/lang-libraries'
+         */
+        dir: string;
+        /**
+         * The import statement used in generated library files to import the project's `lang` tag function.
+         * @default 'import { lang } from "@/my-lang-tag-path"'
+         */
+        tagImportPath: string;
+        /**
+         * A function to customize the generated file name and export name for imported library tags.
+         * Allows controlling how imported tags are organized and named within the generated files.
+         */
+        onImport: (params: LangTagCLIOnImportParams, actions: LangTagCLIOnImportActions) => void;
+        /**
+         * A function called after all lang-tags were imported
+         */
+        onImportFinish?: () => void;
+    };
+    /**
+     * Determines the position of the translation argument in the `lang()` function.
+     * If `1`, translations are in the first argument (`lang(translations, options)`).
+     * If `2`, translations are in the second argument (`lang(options, translations)`).
+     * @default 1
+     */
+    translationArgPosition: 1 | 2;
     debug?: boolean;
 }
 /**