@lang-tag/cli 0.14.0 → 0.15.0

package/algorithms/collector/dictionary-collector.d.ts

@@ -0,0 +1,17 @@
+import { TranslationsCollector } from './type.ts';
+import { LangTagCLIProcessedTag } from '../../config.ts';
+interface Options {
+    appendNamespaceToPath: boolean;
+}
+export declare class DictionaryCollector extends TranslationsCollector {
+    private readonly options;
+    private clean;
+    constructor(options?: Options);
+    aggregateCollection(namespace: string): string;
+    transformTag(tag: LangTagCLIProcessedTag): LangTagCLIProcessedTag;
+    preWrite(clean: boolean): Promise<void>;
+    resolveCollectionFilePath(baseLanguageCode: string): Promise<any>;
+    onMissingCollection(baseLanguageCode: string): Promise<void>;
+    postWrite(changedCollections: string[]): Promise<void>;
+}
+export {};

package/algorithms/collector/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Translation collectors for organizing translation tags into output files.
+ *
+ * These collectors define how translation tags are grouped and written to files
+ * during the collection process. Each collector implements a different strategy
+ * for organizing translations (e.g., single dictionary vs. namespace-based files).
+ */
+export { DictionaryCollector } from './dictionary-collector.ts';
+export { NamespaceCollector } from './namespace-collector.ts';
+export { type TranslationsCollector } from './type.ts';

package/algorithms/collector/namespace-collector.d.ts

@@ -0,0 +1,12 @@
+import { TranslationsCollector } from './type.ts';
+import { LangTagCLIProcessedTag } from '../../config.ts';
+export declare class NamespaceCollector extends TranslationsCollector {
+    private clean;
+    private languageDirectory;
+    aggregateCollection(namespace: string): string;
+    transformTag(tag: LangTagCLIProcessedTag): LangTagCLIProcessedTag;
+    preWrite(clean: boolean): Promise<void>;
+    resolveCollectionFilePath(collectionName: string): Promise<any>;
+    onMissingCollection(collectionName: string): Promise<void>;
+    postWrite(changedCollections: string[]): Promise<void>;
+}

package/algorithms/collector/type.d.ts

@@ -0,0 +1,12 @@
+import { LangTagCLIConfig, LangTagCLIProcessedTag } from '../../config.ts';
+import { LangTagCLILogger } from '../../logger.ts';
+export declare abstract class TranslationsCollector {
+    config: LangTagCLIConfig;
+    logger: LangTagCLILogger;
+    abstract aggregateCollection(namespace: string): string;
+    abstract transformTag(tag: LangTagCLIProcessedTag): LangTagCLIProcessedTag;
+    abstract preWrite(clean?: boolean): Promise<void>;
+    abstract resolveCollectionFilePath(collectionName: string): Promise<string>;
+    abstract onMissingCollection(collectionName: string): Promise<void>;
+    abstract postWrite(changedCollections: string[]): Promise<void>;
+}

package/algorithms/config-generation/index.d.ts

@@ -6,3 +6,4 @@
  */
 export { pathBasedConfigGenerator, type PathBasedConfigGeneratorOptions } from './path-based-config-generator.ts';
 export { configKeeper, type ConfigKeeperOptions, type ConfigKeeperMode } from './config-keeper.ts';
+export { prependNamespaceToPath, type PrependNamespaceToPathOptions } from './prepend-namespace-to-path.ts';

package/algorithms/config-generation/prepend-namespace-to-path.d.ts

@@ -0,0 +1,28 @@
+import { LangTagCLIConfigGenerationEvent } from '../../config.ts';
+/**
+ * Options for the prependNamespaceToPath algorithm.
+ */
+export interface PrependNamespaceToPathOptions {
+}
+/**
+ * Algorithm that prepends the namespace to the path in translation tag configurations.
+ *
+ * This is useful when you want to flatten the namespace structure by moving the namespace
+ * into the path, effectively removing the namespace separation.
+ *
+ * @example
+ * ```typescript
+ * // Before: { namespace: 'common', path: 'hello.world' }
+ * // After:  { path: 'common.hello.world' }
+ *
+ * // Before: { namespace: 'common' }
+ * // After:  { path: 'common' }
+ *
+ * // Before: {}
+ * // After:  { path: 'common' }
+ * ```
+ *
+ * @param options Configuration options for the algorithm
+ * @returns A function compatible with LangTagCLIConfigGenerationEvent
+ */
+export declare function prependNamespaceToPath(options?: PrependNamespaceToPathOptions): (event: LangTagCLIConfigGenerationEvent) => Promise<void>;

package/algorithms/index.cjs

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const namespaceCollector = require("../namespace-collector-DRnZvkDR.cjs");
 const path = require("pathe");
+const process = require("node:process");
 const caseLib = require("case");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
@@ -19,7 +21,74 @@ function _interopNamespaceDefault(e) {
   return Object.freeze(n);
 }
 const caseLib__namespace = /* @__PURE__ */ _interopNamespaceDefault(caseLib);
-const TRIGGER_NAME$1 = "path-based-config-generator";
+class DictionaryCollector extends namespaceCollector.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 namespaceCollector.$LT_RemoveFile(baseDictionaryFile);
+    }
+    await namespaceCollector.$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 });
+    }
+  }
+  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 TRIGGER_NAME$2 = "path-based-config-generator";
 function pathBasedConfigGenerator(options = {}) {
   const {
     includeFileName = false,
@@ -109,7 +178,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 +196,7 @@ function pathBasedConfigGenerator(options = {}) {
       }
     }
     if (Object.keys(newConfig).length > 0) {
-      event.save(newConfig, TRIGGER_NAME$1);
+      event.save(newConfig, TRIGGER_NAME$2);
     }
   };
 }
@@ -313,7 +382,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 +439,33 @@ 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);
   };
 }
+exports.NamespaceCollector = namespaceCollector.NamespaceCollector;
+exports.DictionaryCollector = DictionaryCollector;
 exports.configKeeper = configKeeper;
 exports.pathBasedConfigGenerator = pathBasedConfigGenerator;
+exports.prependNamespaceToPath = prependNamespaceToPath;

package/algorithms/index.d.ts

@@ -1,7 +1,10 @@
 /**
- * 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 (future)
  */
+export * from './collector/index.ts';
 export * from './config-generation/index.ts';

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,13 +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 {
-        path = "";
+        path2 = "";
       }
     } else {
       namespace = actualFallbackNamespace;
@@ -75,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;
@@ -101,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);
     }
   };
 }
@@ -294,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;
@@ -351,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;
 }
 /**