@lang-tag/cli 0.16.0 → 0.18.0

package/logger.d.ts

@@ -1,4 +1,4 @@
-import { LangTagCLIConflict } from './config.ts';
+import { LangTagCLIConflict } from './type';
 export interface LangTagCLILogger {
     info(message: string, params?: Record<string, any>): void;
     success(message: string, params?: Record<string, any>): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lang-tag/cli",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -33,6 +33,10 @@
     "lang-tag": "*"
   },
   "dependencies": {
+    "@inquirer/checkbox": "^4.3.0",
+    "@inquirer/confirm": "^5.1.19",
+    "@inquirer/prompts": "^7.9.0",
+    "@inquirer/select": "^4.4.0",
     "acorn": "^8.15.0",
     "case": "^1.6.3",
     "chokidar": "^4.0.3",

package/templates/config/config.mustache

@@ -0,0 +1,180 @@
+/**
+ * Lang Tag CLI Configuration
+ * 
+ * This file was generated. You can modify it to customize your translation workflow.
+ * Documentation: https://github.com/TheTonsOfCode/lang-tag-cli
+ */
+
+{{#needsAlgorithms}}
+{{#isCJS}}const{{/isCJS}}{{^isCJS}}import{{/isCJS}} {
+{{#needsPathBasedImport}}
+    pathBasedConfigGenerator,
+{{/needsPathBasedImport}}
+{{#useKeeper}}
+    configKeeper,
+{{/useKeeper}}
+{{#isDictionaryCollector}}
+    DictionaryCollector,
+{{/isDictionaryCollector}}
+{{#isModifiedNamespaceCollector}}
+    NamespaceCollector,
+{{/isModifiedNamespaceCollector}}
+{{#importLibraries}}
+    flexibleImportAlgorithm,
+{{/importLibraries}}
+} {{#isCJS}}= require('@lang-tag/cli/algorithms');{{/isCJS}}{{^isCJS}}from '@lang-tag/cli/algorithms';{{/isCJS}}
+{{/needsAlgorithms}}
+
+{{#needsPathBasedImport}}
+{{>generation-algorithm}}
+{{/needsPathBasedImport}}
+{{#useKeeper}}
+{{#addComments}}
+// Preserves tags marked with keep property. Example: {{tagName}}({ text: 'text'}, { namespace: 'custom', keep: 'namespace' })
+{{/addComments}}
+    const keeper = configKeeper({ propertyName: 'keep' });
+
+{{/useKeeper}}
+/** @type {import('@lang-tag/cli/type').LangTagCLIConfig} */
+const config = {
+{{#needsTagName}}
+    tagName: '{{tagName}}',
+{{/needsTagName}}
+{{#isLibrary}}
+    isLibrary: true,
+{{/isLibrary}}
+{{#addComments}}
+    // Directories where we’re going to look for language tags
+{{/addComments}}
+    includes: [{{includes}}],
+    excludes: [{{excludes}}],
+{{^isLibrary}}
+    localesDirectory: '{{localesDirectory}}',
+{{/isLibrary}}
+{{#addComments}}
+    // The source translations language used in your code (e.g., 'en', 'pl')
+{{/addComments}}
+    baseLanguageCode: '{{baseLanguageCode}}',
+{{#hasConfigGeneration}}
+{{#usePathBased}}
+{{#addComments}}
+    /**
+     * Automatically generates namespace/path from file location.
+     * Example: src/features/auth/LoginForm.tsx → { namespace: 'auth', path: 'loginForm' }
+     * 
+     * To customize, modify generationAlgorithm options above or add custom logic:
+     * - Change case formatting (namespaceCase, pathCase)
+     * - Ignore specific directories (ignoreDirectories)
+     * - Add path transformation rules (pathRules)
+     */
+{{/addComments}}
+    onConfigGeneration: async event => {
+        // We do not modify imported configurations
+        if (event.isImportedLibrary) return;
+{{#useKeeper}}
+        if (event.config?.keep === 'both') return;
+{{/useKeeper}}
+        
+        await generationAlgorithm(event);
+{{#useKeeper}}
+        await keeper(event);
+{{/useKeeper}}
+    },
+{{/usePathBased}}
+{{#useCustom}}
+{{#addComments}}
+    /**
+     * Custom hook to generate namespace/path for each tag based on file location.
+     * 
+     * Sample properties:
+     * - event.relativePath: File path relative to project root (e.g., 'src/auth/Login.tsx')
+     * - event.config: Current tag config (may be undefined or contain user-provided values)
+     * - event.save(newConfig): Save new config. Example: event.save({ namespace: 'auth', path: 'login' })
+     * 
+     * Example - generate from directory structure:
+     *   const segments = event.relativePath.split('/').slice(1, -1);
+     *   event.save({ namespace: segments[0], path: segments.slice(1).join('.') });
+     */
+{{/addComments}}
+    onConfigGeneration: async event => {
+        // We do not modify imported configurations
+        if (event.isImportedLibrary) return;
+
+{{#useKeeper}}
+        if (event.config?.keep === 'both') return;
+{{/useKeeper}}
+        // TODO: Implement your custom config generation logic here
+        // event.save({
+        //     namespace: 'your-namespace',
+        //     path: 'your.path'
+        // });
+{{#useKeeper}}
+    await keeper(event);
+{{/useKeeper}}
+    },
+{{/useCustom}}
+{{/hasConfigGeneration}}
+{{#hasCollectContent}}
+    collect: {
+{{#isDictionaryCollector}}
+{{#addComments}}
+        // All translations in one file per language. Change to NamespaceCollector() for separate files per namespace.
+{{/addComments}}
+        collector: new DictionaryCollector(),
+{{/isDictionaryCollector}}
+{{#isModifiedNamespaceCollector}}
+{{#addComments}}
+        // Separate file per namespace (e.g., locales/en/auth.json, locales/en/dashboard.json)
+{{/addComments}}
+        collector: new NamespaceCollector(),
+{{/isModifiedNamespaceCollector}}
+{{^isDictionary}}
+{{^isDefaultNamespace}}
+{{#addComments}}
+        // Tags without config or namespace in config will use this
+{{/addComments}}
+        defaultNamespace: '{{defaultNamespace}}',
+{{/isDefaultNamespace}}
+{{/isDictionary}}
+{{#interfereWithCollection}}
+{{#addComments}}
+        /**
+         * Called for each duplicate key conflict (same namespace + path, different values).
+         * To stop on first conflict, call event.exit() here instead of in onCollectFinish.
+         */
+{{/addComments}}
+        onConflictResolution: async event => {
+            await event.logger.conflict(event.conflict, true);
+            // By default, continue processing even if conflicts occur
+            // Call event.exit(); to terminate the process upon the first conflict
+        },
+{{#addComments}}
+        /**
+         * Called after collection completes. Check event.conflicts array to handle all conflicts.
+         * Remove this hook to allow merging despite conflicts.
+         */
+{{/addComments}}
+        onCollectFinish: event => {
+            if (event.conflicts.length) event.exit(); // Stop the process to avoid merging on conflict
+        }
+{{/interfereWithCollection}}
+    },
+{{/hasCollectContent}}
+{{#importLibraries}}
+{{#addComments}}
+    /**
+     * Imports translations from external libraries (node modules packages containing exported 'lang-tags.json').
+     * - dir: Where to generate import files
+     * - tagImportPath: Update path to your tag function
+     * - onImport: Controls file naming/structure (see flexibleImportAlgorithm options)
+     */
+{{/addComments}}
+    import: {
+        dir: 'src/lang-libraries',
+        tagImportPath: 'import { {{tagName}} } from "@/my-lang-tag-path"',
+        onImport: flexibleImportAlgorithm({ filePath: { includePackageInPath: true } })
+    },
+{{/importLibraries}}
+};
+
+{{#isCJS}}module.exports = config;{{/isCJS}}{{^isCJS}}export default config;{{/isCJS}}

package/templates/config/generation-algorithm.mustache

@@ -0,0 +1,73 @@
+{{#addComments}}
+/**
+ * Generates namespace/path from directory structure (filename is excluded).
+ * 
+ * Example with current settings (assuming includes: ['src/**']):
+ *   File: src/(admin)/features/auth/utils/LoginForm.tsx
+ *   1. Remove filename → src/(admin)/features/auth/utils
+ *   2. Remove root 'src' → (admin)/features/auth/utils
+ *   3. Remove bracketed '(admin)' → features/auth/utils
+ *   4. Remove 'utils' (in ignoreDirectories) → features/auth
+ *   5. First segment = namespace, rest = path → namespace: 'features', path: 'auth'
+ */
+{{/addComments}}
+const generationAlgorithm = pathBasedConfigGenerator({
+{{#addComments}}
+    // Removes root directory from includes patterns (e.g., 'src' if includes: ['src/**'])
+{{/addComments}}
+    ignoreIncludesRootDirectories: true,
+{{#addComments}}
+    // Directories with () or [] are NOT used for namespace/path generation
+    // true: app/(admin)/[id]/page.tsx → app/page (completely removed)
+    // false: app/(admin)/[id]/page.tsx → app/admin/id/page (brackets removed, names kept)
+{{/addComments}}
+    removeBracketedDirectories: true,
+{{#addComments}}
+    // Case for namespace. Options: 'kebab', 'camel', 'pascal', 'snake'
+{{/addComments}}
+    namespaceCase: 'kebab',
+{{#addComments}}
+    // Case for path. Options: 'kebab', 'camel', 'pascal', 'snake'
+{{/addComments}}
+    pathCase: 'camel',
+{{#addComments}}
+    // If namespace equals defaultNamespace, omit it from config (namespace becomes undefined)
+{{/addComments}}
+    clearOnDefaultNamespace: true,
+{{#addComments}}
+    // Skip these directory names globally when building namespace/path
+{{/addComments}}
+    ignoreDirectories: ['core', 'utils', 'helpers'],{{#addComments}}
+    /**
+     * Advanced: pathRules for hierarchical transformations
+     * 
+     * Special operators:
+     * - _: false → ignore current directory, continue with nested rules
+     * - '>': 'newName' → rename directory in namespace
+     * - '>>': redirect → jump to different namespace
+     *   - '>>': 'namespace' → use specified namespace, remaining segments become path
+     *   - '>>': { namespace: 'ui', pathPrefix: 'admin' } → jump to 'ui' namespace with 'admin.' prefix
+     *   - '>>': '' or null → use current directory as namespace
+     * 
+     * Example usage:
+     */
+    // pathRules: {
+    //     app: {
+    //         dashboard: {
+    //             _: false,          // ignore "dashboard" but continue with nested rules
+    //             modules: false     // also ignore "modules"
+    //         },
+    //         admin: {
+    //             '>': 'management', // rename "admin" to "management"
+    //             users: false       // ignore "users"
+    //         },
+    //         components: {
+    //             '>>': {            // jump to 'ui' namespace, prefix all paths with 'components'
+    //                 namespace: 'ui',
+    //                 pathPrefix: 'components'
+    //             }
+    //         }
+    //     }
+    // }{{/addComments}}
+});
+

package/{config.d.ts → type.d.ts}

@@ -1,6 +1,6 @@
 import { LangTagTranslationsConfig } from 'lang-tag';
-import { LangTagCLILogger } from './logger.ts';
-import { TranslationsCollector } from './algorithms';
+import { TranslationsCollector } from './algorithms/collector/type';
+import { LangTagCLILogger } from './logger';
 export interface LangTagCLIConfig {
     /**
      * Tag name used to mark translations in code.
@@ -214,6 +214,7 @@ export interface LangTagCLIConfigGenerationEvent {
      * To update the configuration, use the `save()` method with a new configuration object.
      */
     readonly config: Readonly<LangTagTranslationsConfig> | undefined;
+    readonly logger: LangTagCLILogger;
     readonly langTagConfig: LangTagCLIConfig;
     /**
      * Indicates whether the `save()` method has been called during this event.
@@ -250,5 +251,4 @@ export interface LangTagCLICollectFinishEvent {
     /** Breaks translation collection process */
     exit(): void;
 }
-export declare const LANG_TAG_DEFAULT_CONFIG: LangTagCLIConfig;
 export {};

package/flexible-import-algorithm-C-S1c742.js

@@ -1,311 +0,0 @@
-import { mkdir, writeFile, readFile, rm } from "fs/promises";
-import { dirname, resolve } from "path";
-import path, { resolve as resolve$1, join } from "pathe";
-import process__default from "node:process";
-import * as caseLib from "case";
-import micromatch from "micromatch";
-function applyCaseTransform(str, caseType) {
-  if (caseType === "no") {
-    return str;
-  }
-  const caseFunction = caseLib[caseType];
-  if (typeof caseFunction === "function") {
-    return caseFunction(str);
-  }
-  return str;
-}
-class TranslationsCollector {
-  config;
-  logger;
-}
-async function $LT_EnsureDirectoryExists(filePath) {
-  await mkdir(filePath, { recursive: true });
-}
-async function $LT_RemoveDirectory(dirPath) {
-  try {
-    await rm(dirPath, { recursive: true, force: true });
-  } catch (error) {
-  }
-}
-async function $LT_RemoveFile(filePath) {
-  try {
-    await rm(filePath, { force: true });
-  } catch (error) {
-  }
-}
-async function $LT_WriteJSON(filePath, data) {
-  await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
-}
-async function $LT_ReadJSON(filePath) {
-  const content = await readFile(filePath, "utf-8");
-  return JSON.parse(content);
-}
-async function $LT_WriteFileWithDirs(filePath, content) {
-  const dir = dirname(filePath);
-  try {
-    await mkdir(dir, { recursive: true });
-  } catch (error) {
-  }
-  await writeFile(filePath, content, "utf-8");
-}
-async function $LT_ReadFileContent(relativeFilePath) {
-  const cwd = process.cwd();
-  const absolutePath = resolve(cwd, relativeFilePath);
-  return await readFile(absolutePath, "utf-8");
-}
-class NamespaceCollector extends TranslationsCollector {
-  clean;
-  languageDirectory;
-  aggregateCollection(namespace) {
-    return namespace;
-  }
-  transformTag(tag) {
-    return tag;
-  }
-  async preWrite(clean) {
-    this.clean = clean;
-    this.languageDirectory = path.join(this.config.localesDirectory, this.config.baseLanguageCode);
-    if (clean) {
-      this.logger.info("Cleaning output directory...");
-      await $LT_RemoveDirectory(this.languageDirectory);
-    }
-    await $LT_EnsureDirectoryExists(this.languageDirectory);
-  }
-  async resolveCollectionFilePath(collectionName) {
-    return resolve$1(
-      process__default.cwd(),
-      this.languageDirectory,
-      collectionName + ".json"
-    );
-  }
-  async onMissingCollection(collectionName) {
-    if (!this.clean) {
-      this.logger.warn(`Original namespace file "{namespace}.json" not found. A new one will be created.`, { namespace: collectionName });
-    }
-  }
-  async postWrite(changedCollections) {
-    if (!changedCollections?.length) {
-      this.logger.info("No changes were made based on the current configuration and files");
-      return;
-    }
-    const n = changedCollections.map((n2) => `"${n2}.json"`).join(", ");
-    this.logger.success("Updated namespaces {outputDir} ({namespaces})", {
-      outputDir: this.config.localesDirectory,
-      namespaces: n
-    });
-  }
-}
-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, importManager, logger } = event;
-    for (const { packageJSON, exportData } of exports) {
-      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 ${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 ${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 join(transformedPackageName, transformedFilePath);
-    } else {
-      const transformedPackageName = applyCaseTransform(normalizedPackageName, caseType.directories || "no");
-      const transformedFilePath = applyCaseTransformToPath(originalFileName, caseType);
-      return 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);
-}
-export {
-  $LT_ReadFileContent as $,
-  NamespaceCollector as N,
-  TranslationsCollector as T,
-  $LT_ReadJSON as a,
-  $LT_WriteJSON as b,
-  $LT_EnsureDirectoryExists as c,
-  $LT_WriteFileWithDirs as d,
-  $LT_RemoveFile as e,
-  flexibleImportAlgorithm as f,
-  applyCaseTransform as g
-};