@lang-tag/cli 0.13.1 → 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/path-based-config-generator.d.ts

@@ -67,6 +67,12 @@ export interface PathBasedConfigGeneratorOptions {
      * Supports ignoring and renaming segments with special keys:
      * - `_`: when `false`, ignores the current segment but continues hierarchy
      * - `>`: renames the current segment to the specified value
+     * - `>>`: namespace redirect - jumps to a different namespace and continues processing remaining path segments
+     *   - String: `>>: 'namespace'` - redirects to specified namespace, remaining segments become path
+     *   - Object: `>>: { namespace: 'name', pathPrefix: 'prefix.' }` - redirects with optional path prefix
+     *   - Empty: `>>: ''` or `>>: null/undefined` - uses current segment as namespace
+     *   - Missing namespace: `>>: { pathPrefix: 'prefix.' }` - uses current segment as namespace with prefix
+     *   - Nested: deepest `>>` in hierarchy takes precedence
      * - Regular keys: nested rules or boolean/string for child segments
      *
      * @example
@@ -79,6 +85,25 @@ export interface PathBasedConfigGeneratorOptions {
      *     admin: {
      *       '>': 'management', // rename "admin" to "management"
      *       users: true        // keep "users" as is (does nothing)
+     *     },
+     *     layout: {
+     *       '>>': 'dashboard'  // redirect: everything below layout jumps to "dashboard" namespace
+     *     },
+     *     components: {
+     *       '>>': {           // redirect: jump to "ui" namespace with "components." path prefix
+     *         namespace: 'ui',
+     *         pathPrefix: 'components'
+     *       }
+     *     },
+     *     features: {
+     *       '>>': {           // redirect: use current segment as namespace with "feature." prefix
+     *         pathPrefix: 'feature.'
+     *       }
+     *     },
+     *     auth: {
+     *       '>>': '',         // redirect: use current segment as namespace
+     *       '>>': null,       // same as empty string
+     *       '>>': undefined   // same as empty string
      *     }
      *   }
      * }

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,
@@ -80,6 +149,8 @@ function pathBasedConfigGenerator(options = {}) {
       namespace = pathSegments[0];
       if (pathSegments.length > 1) {
         path$1 = pathSegments.slice(1).join(".");
+      } else {
+        path$1 = "";
       }
     } else {
       namespace = actualFallbackNamespace;
@@ -107,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;
@@ -125,7 +196,7 @@ function pathBasedConfigGenerator(options = {}) {
       }
     }
     if (Object.keys(newConfig).length > 0) {
-      event.save(newConfig, TRIGGER_NAME$1);
+      event.save(newConfig, TRIGGER_NAME$2);
     }
   };
 }
@@ -163,11 +234,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) {
@@ -190,6 +319,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);
@@ -204,6 +349,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) {
@@ -230,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;
@@ -287,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';