@lang-tag/cli 0.10.0 → 0.11.0

package/README.md

@@ -1,4 +1,4 @@
-# Lang-tag: Component-Colocated Translation Management / Translation Engine Proxy
+# Lang-tag CLI
 
 A professional solution for managing translations in modern JavaScript/TypeScript projects, especially those using component-based architectures. `lang-tag` simplifies internationalization by allowing you to define translation keys directly within the components where they are used. Translations become local, callable function objects with full TypeScript support, IntelliSense, and compile-time safety.
 

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

@@ -0,0 +1,7 @@
+/**
+ * Predefined algorithms for onConfigGeneration hook.
+ *
+ * These algorithms customize how translation tag configurations are generated
+ * during collection and regeneration.
+ */
+export { pathBasedConfigGenerator, type PathBasedConfigGeneratorOptions } from './path-based-config-generator.ts';

package/algorithms/config-generation/path-based-config-generator.d.ts

@@ -0,0 +1,110 @@
+import { LangTagCLIConfigGenerationEvent } from '../../config.ts';
+export interface PathBasedConfigGeneratorOptions {
+    /**
+     * Whether to include the filename (without extension) as part of the path segments.
+     * @default false
+     */
+    includeFileName?: boolean;
+    /**
+     * Whether to completely remove folders wrapped in brackets () or [].
+     * If false, only the brackets are removed from folder names.
+     * @default true
+     *
+     * @example
+     * - true: 'app/(admin)/users' -> 'app/users'
+     * - false: 'app/(admin)/users' -> 'app/admin/users'
+     */
+    removeBracketedFolders?: boolean;
+    /**
+     * List of folder names to completely ignore globally.
+     * These will be removed from all paths regardless of their position.
+     * @default []
+     *
+     * @example ['src', 'app', 'components']
+     */
+    ignoreFolders?: string[];
+    /**
+     * When true, automatically extracts root folder names from the config.includes patterns
+     * and adds them to the ignoreFolders list.
+     *
+     * @default false
+     *
+     * @example
+     * // With includes: ['src/**\/*.{js,ts,jsx,tsx}']
+     * // Automatically ignores: ['src']
+     *
+     * // With includes: ['(src|app)/**\/*.{js,ts,jsx,tsx}', 'components/**\/*.{jsx,tsx}']
+     * // Automatically ignores: ['src', 'app', 'components']
+     */
+    ignoreIncludesRootFolders?: boolean;
+    /**
+     * Hierarchical structure for ignoring specific folder patterns.
+     * Keys represent path segments to match, values indicate what to ignore at that level.
+     *
+     * @example
+     * {
+     *   'src': {
+     *     'app': true,  // ignore 'app' when under 'src'
+     *     'features': ['auth', 'admin']  // ignore 'auth' and 'admin' under 'src/features'
+     *   }
+     * }
+     */
+    ignoreStructured?: Record<string, any>;
+    /**
+     * Convert the final namespace to lowercase.
+     * @default false
+     */
+    lowercaseNamespace?: boolean;
+    /**
+     * Case transformation to apply to the namespace.
+     * Available options: 'camel', 'capital', 'constant', 'dot', 'header', 'kebab',
+     * 'lower', 'no', 'param', 'pascal', 'path', 'sentence', 'snake', 'swap', 'title', 'upper'
+     * @default undefined (no transformation)
+     */
+    namespaceCase?: 'camel' | 'capital' | 'constant' | 'dot' | 'header' | 'kebab' | 'lower' | 'no' | 'param' | 'pascal' | 'path' | 'sentence' | 'snake' | 'swap' | 'title' | 'upper';
+    /**
+     * Case transformation to apply to the path segments.
+     * Available options: 'camel', 'capital', 'constant', 'dot', 'header', 'kebab',
+     * 'lower', 'no', 'param', 'pascal', 'path', 'sentence', 'snake', 'swap', 'title', 'upper'
+     * @default undefined (no transformation)
+     */
+    pathCase?: 'camel' | 'capital' | 'constant' | 'dot' | 'header' | 'kebab' | 'lower' | 'no' | 'param' | 'pascal' | 'path' | 'sentence' | 'snake' | 'swap' | 'title' | 'upper';
+    /**
+     * Fallback namespace to use when no segments remain after filtering.
+     * Defaults to the defaultNamespace from langTagConfig.collect.defaultNamespace if not provided.
+     * @default undefined
+     */
+    fallbackNamespace?: string;
+    /**
+     * When true and the generated namespace equals the fallback/default namespace,
+     * the namespace will be omitted from the configuration as it's redundant.
+     * @default true
+     */
+    clearOnDefaultNamespace?: boolean;
+}
+/**
+ * Automatically generates namespace and path configuration based on file path structure.
+ *
+ * This algorithm analyzes the relative file path and intelligently extracts namespace
+ * and path segments according to configurable rules.
+ *
+ * @param options - Configuration options for path-based generation
+ * @returns A function compatible with LangTagCLIConfig.onConfigGeneration
+ *
+ * @example
+ * ```typescript
+ * import { pathBasedConfigGenerator } from '@lang-tag/cli/algorithms';
+ *
+ * export default {
+ *   onConfigGeneration: pathBasedConfigGenerator({
+ *     includeFileName: false,
+ *     removeBracketedFolders: true,
+ *     ignoreFolders: ['lib', 'utils'],
+ *     ignoreIncludesRootFolders: true, // Auto-ignores root folders from includes
+ *     lowercaseNamespace: true,
+ *     fallbackNamespace: 'common'
+ *   })
+ * };
+ * ```
+ */
+export declare function pathBasedConfigGenerator(options?: PathBasedConfigGeneratorOptions): (event: LangTagCLIConfigGenerationEvent) => Promise<void>;

package/algorithms/import/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Predefined algorithms for onImport hook.
+ *
+ * These algorithms customize how library translations are imported
+ * and organized in your project.
+ */
+export {};

package/algorithms/index.cjs

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const caseLib__namespace = /* @__PURE__ */ _interopNamespaceDefault(caseLib);
+function pathBasedConfigGenerator(options = {}) {
+  const {
+    includeFileName = false,
+    removeBracketedFolders = true,
+    ignoreFolders = [],
+    ignoreIncludesRootFolders = false,
+    ignoreStructured = {},
+    lowercaseNamespace = false,
+    namespaceCase,
+    pathCase,
+    fallbackNamespace,
+    clearOnDefaultNamespace = true
+  } = options;
+  return async (event) => {
+    const { relativePath, langTagConfig } = event;
+    const actualFallbackNamespace = fallbackNamespace ?? langTagConfig.collect?.defaultNamespace;
+    let finalIgnoreFolders = [...ignoreFolders];
+    if (ignoreIncludesRootFolders && langTagConfig.includes) {
+      const extractedFolders = extractRootFoldersFromIncludes(langTagConfig.includes);
+      finalIgnoreFolders = [.../* @__PURE__ */ new Set([...finalIgnoreFolders, ...extractedFolders])];
+    }
+    let pathSegments = relativePath.split(path.sep).filter(Boolean);
+    if (pathSegments.length === 0) {
+      return;
+    }
+    const fileName = pathSegments[pathSegments.length - 1];
+    const fileNameWithoutExt = fileName.replace(/\.[^.]+$/, "");
+    if (includeFileName) {
+      pathSegments[pathSegments.length - 1] = fileNameWithoutExt;
+    } else {
+      pathSegments = pathSegments.slice(0, -1);
+    }
+    pathSegments = pathSegments.map((segment) => {
+      const bracketMatch = segment.match(/^[\(\[](.+)[\)\]]$/);
+      if (bracketMatch) {
+        return removeBracketedFolders ? null : bracketMatch[1];
+      }
+      return segment;
+    }).filter((seg) => seg !== null);
+    pathSegments = applyStructuredIgnore(pathSegments, ignoreStructured);
+    pathSegments = pathSegments.filter((seg) => !finalIgnoreFolders.includes(seg));
+    let namespace;
+    let path$1;
+    if (pathSegments.length >= 1) {
+      namespace = pathSegments[0];
+      if (pathSegments.length > 1) {
+        path$1 = pathSegments.slice(1).join(".");
+      }
+    } else {
+      namespace = actualFallbackNamespace;
+    }
+    if (namespace) {
+      if (lowercaseNamespace) {
+        namespace = namespace.toLowerCase();
+      }
+      if (namespaceCase) {
+        namespace = applyCaseTransform(namespace, namespaceCase);
+      }
+    }
+    if (path$1 && pathCase) {
+      const pathParts = path$1.split(".");
+      const transformedParts = pathParts.map((part) => applyCaseTransform(part, pathCase));
+      path$1 = transformedParts.join(".");
+    }
+    const newConfig = {};
+    if (clearOnDefaultNamespace && namespace === actualFallbackNamespace) {
+      if (path$1) {
+        newConfig.path = path$1;
+      } else {
+        event.save(void 0);
+        return;
+      }
+    } else {
+      if (namespace) {
+        newConfig.namespace = namespace;
+      }
+      if (path$1) {
+        newConfig.path = path$1;
+      }
+    }
+    if (Object.keys(newConfig).length > 0) {
+      event.save(newConfig);
+    }
+  };
+}
+function applyStructuredIgnore(segments, structure) {
+  const result = [];
+  let currentStructure = structure;
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    if (segment in currentStructure) {
+      const rule = currentStructure[segment];
+      if (rule === true) {
+        currentStructure = structure;
+        continue;
+      } else if (Array.isArray(rule)) {
+        result.push(segment);
+        if (i + 1 < segments.length && rule.includes(segments[i + 1])) {
+          i++;
+        }
+        currentStructure = structure;
+        continue;
+      } else if (typeof rule === "object" && rule !== null) {
+        result.push(segment);
+        currentStructure = rule;
+        continue;
+      }
+    }
+    result.push(segment);
+    currentStructure = structure;
+  }
+  return result;
+}
+function applyCaseTransform(str, caseType) {
+  const caseFunction = caseLib__namespace[caseType];
+  if (typeof caseFunction === "function") {
+    return caseFunction(str);
+  }
+  return str;
+}
+function extractRootFoldersFromIncludes(includes) {
+  const folders = /* @__PURE__ */ new Set();
+  for (const pattern of includes) {
+    let cleanPattern = pattern.replace(/^\.\//, "");
+    const match = cleanPattern.match(/^([^/]+)/);
+    if (!match) continue;
+    const firstSegment = match[1];
+    const groupMatch = firstSegment.match(/^[\(\[]([^\)\]]+)[\)\]]$/);
+    if (groupMatch) {
+      const groupFolders = groupMatch[1].split("|").map((f) => f.trim());
+      groupFolders.forEach((folder) => folders.add(folder));
+    } else {
+      folders.add(firstSegment);
+    }
+  }
+  return Array.from(folders);
+}
+exports.pathBasedConfigGenerator = pathBasedConfigGenerator;

package/algorithms/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Predefined algorithms for lang-tag-cli configuration.
+ *
+ * These algorithms can be used in your lang-tag-cli config file
+ * to customize how tags are processed during collection and regeneration.
+ */
+export { pathBasedConfigGenerator, type PathBasedConfigGeneratorOptions } from './config-generation/index.ts';

package/algorithms/index.js

@@ -0,0 +1,142 @@
+import { sep } from "pathe";
+import * as caseLib from "case";
+function pathBasedConfigGenerator(options = {}) {
+  const {
+    includeFileName = false,
+    removeBracketedFolders = true,
+    ignoreFolders = [],
+    ignoreIncludesRootFolders = false,
+    ignoreStructured = {},
+    lowercaseNamespace = false,
+    namespaceCase,
+    pathCase,
+    fallbackNamespace,
+    clearOnDefaultNamespace = true
+  } = options;
+  return async (event) => {
+    const { relativePath, langTagConfig } = event;
+    const actualFallbackNamespace = fallbackNamespace ?? langTagConfig.collect?.defaultNamespace;
+    let finalIgnoreFolders = [...ignoreFolders];
+    if (ignoreIncludesRootFolders && langTagConfig.includes) {
+      const extractedFolders = extractRootFoldersFromIncludes(langTagConfig.includes);
+      finalIgnoreFolders = [.../* @__PURE__ */ new Set([...finalIgnoreFolders, ...extractedFolders])];
+    }
+    let pathSegments = relativePath.split(sep).filter(Boolean);
+    if (pathSegments.length === 0) {
+      return;
+    }
+    const fileName = pathSegments[pathSegments.length - 1];
+    const fileNameWithoutExt = fileName.replace(/\.[^.]+$/, "");
+    if (includeFileName) {
+      pathSegments[pathSegments.length - 1] = fileNameWithoutExt;
+    } else {
+      pathSegments = pathSegments.slice(0, -1);
+    }
+    pathSegments = pathSegments.map((segment) => {
+      const bracketMatch = segment.match(/^[\(\[](.+)[\)\]]$/);
+      if (bracketMatch) {
+        return removeBracketedFolders ? null : bracketMatch[1];
+      }
+      return segment;
+    }).filter((seg) => seg !== null);
+    pathSegments = applyStructuredIgnore(pathSegments, ignoreStructured);
+    pathSegments = pathSegments.filter((seg) => !finalIgnoreFolders.includes(seg));
+    let namespace;
+    let path;
+    if (pathSegments.length >= 1) {
+      namespace = pathSegments[0];
+      if (pathSegments.length > 1) {
+        path = pathSegments.slice(1).join(".");
+      }
+    } else {
+      namespace = actualFallbackNamespace;
+    }
+    if (namespace) {
+      if (lowercaseNamespace) {
+        namespace = namespace.toLowerCase();
+      }
+      if (namespaceCase) {
+        namespace = applyCaseTransform(namespace, namespaceCase);
+      }
+    }
+    if (path && pathCase) {
+      const pathParts = path.split(".");
+      const transformedParts = pathParts.map((part) => applyCaseTransform(part, pathCase));
+      path = transformedParts.join(".");
+    }
+    const newConfig = {};
+    if (clearOnDefaultNamespace && namespace === actualFallbackNamespace) {
+      if (path) {
+        newConfig.path = path;
+      } else {
+        event.save(void 0);
+        return;
+      }
+    } else {
+      if (namespace) {
+        newConfig.namespace = namespace;
+      }
+      if (path) {
+        newConfig.path = path;
+      }
+    }
+    if (Object.keys(newConfig).length > 0) {
+      event.save(newConfig);
+    }
+  };
+}
+function applyStructuredIgnore(segments, structure) {
+  const result = [];
+  let currentStructure = structure;
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i];
+    if (segment in currentStructure) {
+      const rule = currentStructure[segment];
+      if (rule === true) {
+        currentStructure = structure;
+        continue;
+      } else if (Array.isArray(rule)) {
+        result.push(segment);
+        if (i + 1 < segments.length && rule.includes(segments[i + 1])) {
+          i++;
+        }
+        currentStructure = structure;
+        continue;
+      } else if (typeof rule === "object" && rule !== null) {
+        result.push(segment);
+        currentStructure = rule;
+        continue;
+      }
+    }
+    result.push(segment);
+    currentStructure = structure;
+  }
+  return result;
+}
+function applyCaseTransform(str, caseType) {
+  const caseFunction = caseLib[caseType];
+  if (typeof caseFunction === "function") {
+    return caseFunction(str);
+  }
+  return str;
+}
+function extractRootFoldersFromIncludes(includes) {
+  const folders = /* @__PURE__ */ new Set();
+  for (const pattern of includes) {
+    let cleanPattern = pattern.replace(/^\.\//, "");
+    const match = cleanPattern.match(/^([^/]+)/);
+    if (!match) continue;
+    const firstSegment = match[1];
+    const groupMatch = firstSegment.match(/^[\(\[]([^\)\]]+)[\)\]]$/);
+    if (groupMatch) {
+      const groupFolders = groupMatch[1].split("|").map((f) => f.trim());
+      groupFolders.forEach((folder) => folders.add(folder));
+    } else {
+      folders.add(firstSegment);
+    }
+  }
+  return Array.from(folders);
+}
+export {
+  pathBasedConfigGenerator
+};

package/config.d.ts

@@ -98,9 +98,12 @@ export interface LangTagCLIConfig {
      * A function called for each found lang tag before processing.
      * Allows dynamic modification of the tag's configuration (namespace, path, etc.)
      * based on the file path or other context.
-     * If it returns `undefined`, the tag's configuration is not automatically generated or updated.
+     *
+     * Changes made inside this function are **applied only if you explicitly call**
+     * `event.save(configuration)`. Returning a value or modifying the event object
+     * without calling `save()` will **not** update the configuration.
      */
-    onConfigGeneration: (params: LangTagCLIOnConfigGenerationParams) => LangTagTranslationsConfig | undefined;
+    onConfigGeneration: (event: LangTagCLIConfigGenerationEvent) => Promise<void>;
     debug?: boolean;
 }
 /**
@@ -131,19 +134,6 @@ export interface LangTagCLIOnImportActions {
     /** Sets the configuration for the currently imported tag. */
     setConfig: (config: LangTagTranslationsConfig) => void;
 }
-/**
- * Parameters passed to the `onConfigGeneration` configuration function.
- */
-export interface LangTagCLIOnConfigGenerationParams {
-    /** The absolute path to the source file being processed. */
-    fullPath: string;
-    /** The path of the source file relative to the project root (where the command was invoked). */
-    path: string;
-    /** True if the file being processed is located within the configured library import directory (`config.import.dir`). */
-    isImportedLibrary: boolean;
-    /** The configuration object extracted from the lang tag's options argument (e.g., `{ namespace: 'common', path: 'my.path' }`). */
-    config: LangTagTranslationsConfig;
-}
 type Validity = 'ok' | 'invalid-param-1' | 'invalid-param-2' | 'translations-not-found';
 export interface LangTagCLIProcessedTag {
     fullMatch: string;
@@ -171,6 +161,22 @@ export interface LangTagCLIConflict {
     tagB: LangTagCLITagConflictInfo;
     conflictType: 'path_overwrite' | 'type_mismatch';
 }
+export interface LangTagCLIConfigGenerationEvent {
+    /** The absolute path to the source file being processed. */
+    absolutePath: string;
+    /** The path of the source file relative to the project root (where the command was invoked). */
+    relativePath: string;
+    /** True if the file being processed is located within the configured library import directory (`config.import.dir`). */
+    isImportedLibrary: boolean;
+    /** The configuration object extracted from the lang tag's options argument (e.g., `{ namespace: 'common', path: 'my.path' }`). */
+    config: LangTagTranslationsConfig | undefined;
+    langTagConfig: LangTagCLIConfig;
+    /**
+     * Tells CLI to replace tag configuration
+     * undefined = means configuration will be removed
+     **/
+    save(config: LangTagTranslationsConfig | undefined): void;
+}
 export interface LangTagCLICollectConfigFixEvent {
     config: LangTagTranslationsConfig;
     langTagConfig: LangTagCLIConfig;

package/index.cjs

@@ -43,6 +43,7 @@ class $LT_TagProcessor {
     const optionalVariableAssignment = `(?:\\s*(\\w+)\\s*=\\s*)?`;
     const matches = [];
     let currentIndex = 0;
+    const skipRanges = this.buildSkipRanges(fileContent);
     const startPattern = new RegExp(`${optionalVariableAssignment}${tagName}\\(\\s*\\{`, "g");
     while (true) {
       startPattern.lastIndex = currentIndex;
@@ -50,6 +51,10 @@ class $LT_TagProcessor {
       if (!startMatch) break;
       const matchStartIndex = startMatch.index;
       const variableName = startMatch[1] || void 0;
+      if (this.isInSkipRange(matchStartIndex, skipRanges)) {
+        currentIndex = matchStartIndex + 1;
+        continue;
+      }
       let braceCount = 1;
       let i = matchStartIndex + startMatch[0].length;
       while (i < fileContent.length && braceCount > 0) {
@@ -115,17 +120,29 @@ class $LT_TagProcessor {
       let validity = "ok";
       let parameter1 = void 0;
       let parameter2 = void 0;
+      if (this.hasTemplateInterpolation(parameter1Text) || parameter2Text && this.hasTemplateInterpolation(parameter2Text)) {
+        currentIndex = matchStartIndex + 1;
+        continue;
+      }
       try {
         parameter1 = JSON5.parse(parameter1Text);
         if (parameter2Text) {
           try {
             parameter2 = JSON5.parse(parameter2Text);
           } catch (error) {
-            validity = "invalid-param-2";
+            try {
+              parameter2 = JSON5.parse(this.escapeNewlinesInStrings(parameter2Text));
+            } catch {
+              validity = "invalid-param-2";
+            }
           }
         }
       } catch (error) {
-        validity = "invalid-param-1";
+        try {
+          parameter1 = JSON5.parse(this.escapeNewlinesInStrings(parameter1Text));
+        } catch {
+          validity = "invalid-param-1";
+        }
       }
       let parameterTranslations = this.config.translationArgPosition === 1 ? parameter1 : parameter2;
       let parameterConfig = this.config.translationArgPosition === 1 ? parameter2 : parameter1;
@@ -191,6 +208,180 @@ class $LT_TagProcessor {
     });
     return fileContent;
   }
+  buildSkipRanges(fileContent) {
+    const ranges = [];
+    let i = 0;
+    while (i < fileContent.length) {
+      const char = fileContent[i];
+      const nextChar = fileContent[i + 1];
+      if (char === "/" && nextChar === "/") {
+        const start = i;
+        i += 2;
+        while (i < fileContent.length && fileContent[i] !== "\n") {
+          i++;
+        }
+        ranges.push([start, i]);
+        continue;
+      }
+      if (char === "/" && nextChar === "*") {
+        const start = i;
+        i += 2;
+        while (i < fileContent.length - 1) {
+          if (fileContent[i] === "*" && fileContent[i + 1] === "/") {
+            i += 2;
+            break;
+          }
+          i++;
+        }
+        ranges.push([start, i]);
+        continue;
+      }
+      if (char === "'") {
+        const start = i;
+        i++;
+        while (i < fileContent.length) {
+          if (fileContent[i] === "\\") {
+            i += 2;
+            continue;
+          }
+          if (fileContent[i] === "'") {
+            i++;
+            break;
+          }
+          i++;
+        }
+        ranges.push([start, i]);
+        continue;
+      }
+      if (char === '"') {
+        const start = i;
+        i++;
+        while (i < fileContent.length) {
+          if (fileContent[i] === "\\") {
+            i += 2;
+            continue;
+          }
+          if (fileContent[i] === '"') {
+            i++;
+            break;
+          }
+          i++;
+        }
+        ranges.push([start, i]);
+        continue;
+      }
+      if (char === "`") {
+        const start = i;
+        i++;
+        while (i < fileContent.length) {
+          if (fileContent[i] === "\\") {
+            i += 2;
+            continue;
+          }
+          if (fileContent[i] === "`") {
+            i++;
+            break;
+          }
+          i++;
+        }
+        ranges.push([start, i]);
+        continue;
+      }
+      i++;
+    }
+    return ranges;
+  }
+  isInSkipRange(position, skipRanges) {
+    for (const [start, end] of skipRanges) {
+      if (position >= start && position < end) {
+        return true;
+      }
+    }
+    return false;
+  }
+  hasTemplateInterpolation(text) {
+    let i = 0;
+    while (i < text.length) {
+      if (text[i] === "`") {
+        i++;
+        while (i < text.length) {
+          if (text[i] === "\\") {
+            i += 2;
+            continue;
+          }
+          if (text[i] === "$" && text[i + 1] === "{") {
+            return true;
+          }
+          if (text[i] === "`") {
+            i++;
+            break;
+          }
+          i++;
+        }
+        continue;
+      }
+      i++;
+    }
+    return false;
+  }
+  escapeNewlinesInStrings(text) {
+    let result = "";
+    let i = 0;
+    while (i < text.length) {
+      const char = text[i];
+      if (char === '"') {
+        result += char;
+        i++;
+        while (i < text.length) {
+          if (text[i] === "\\") {
+            result += text[i] + text[i + 1];
+            i += 2;
+            continue;
+          }
+          if (text[i] === "\n") {
+            result += "\\n";
+            i++;
+            continue;
+          }
+          if (text[i] === '"') {
+            result += text[i];
+            i++;
+            break;
+          }
+          result += text[i];
+          i++;
+        }
+        continue;
+      }
+      if (char === "'") {
+        result += char;
+        i++;
+        while (i < text.length) {
+          if (text[i] === "\\") {
+            result += text[i] + text[i + 1];
+            i += 2;
+            continue;
+          }
+          if (text[i] === "\n") {
+            result += "\\n";
+            i++;
+            continue;
+          }
+          if (text[i] === "'") {
+            result += text[i];
+            i++;
+            break;
+          }
+          result += text[i];
+          i++;
+        }
+        continue;
+      }
+      result += char;
+      i++;
+    }
+    return result;
+  }
 }
 function getLineAndColumn(text, matchIndex) {
   const lines = text.slice(0, matchIndex).split("\n");
@@ -247,13 +438,20 @@ async function checkAndRegenerateFileLangTags(config, logger, file, path$12) {
   }
   const replacements = [];
   for (let tag of tags) {
-    const newConfig = config.onConfigGeneration({
+    let newConfig = void 0;
+    let shouldUpdate = false;
+    await config.onConfigGeneration({
+      langTagConfig: config,
       config: tag.parameterConfig,
-      fullPath: file,
-      path: path$12,
-      isImportedLibrary: path$12.startsWith(libraryImportsDir)
+      absolutePath: file,
+      relativePath: path$12,
+      isImportedLibrary: path$12.startsWith(libraryImportsDir),
+      save: (updatedConfig) => {
+        newConfig = updatedConfig;
+        shouldUpdate = true;
+      }
     });
-    if (newConfig === void 0) {
+    if (!shouldUpdate) {
       continue;
     }
     if (JSON5.stringify(tag.parameterConfig) !== JSON5.stringify(newConfig)) {
@@ -304,7 +502,8 @@ const LANG_TAG_DEFAULT_CONFIG = {
   isLibrary: false,
   language: "en",
   translationArgPosition: 1,
-  onConfigGeneration: (params) => void 0
+  onConfigGeneration: async (event) => {
+  }
 };
 async function $LT_ReadConfig(projectPath) {
   const configPath = path$1.resolve(projectPath, CONFIG_FILE_NAME);
@@ -1099,6 +1298,11 @@ async function $LT_CMD_Collect(options) {
   const { config, logger } = await $LT_GetCommandEssentials();
   logger.info("Collecting translations from source files...");
   const files = await $LT_CollectCandidateFilesWithTags({ config, logger });
+  if (config.debug) {
+    for (let file of files) {
+      logger.debug("Found {count} translations tags inside: {file}", { count: file.tags.length, file: file.relativeFilePath });
+    }
+  }
   if (config.isLibrary) {
     await $LT_WriteAsExportFile({ config, logger, files });
     return;
@@ -1211,29 +1415,35 @@ async function detectModuleSystem() {
     return "cjs";
   }
 }
-function getExportStatement(moduleSystem) {
-  return moduleSystem === "esm" ? "export default config;" : "module.exports = config;";
-}
 async function generateDefaultConfig() {
   const moduleSystem = await detectModuleSystem();
-  const exportStatement = getExportStatement(moduleSystem);
-  return `/** @type {import('@lang-tag/cli/config').LangTagCLIConfig} */
+  const importStatement = moduleSystem === "esm" ? `import { pathBasedConfigGenerator } from '@lang-tag/cli/algorithms';` : `const { pathBasedConfigGenerator } = require('@lang-tag/cli/algorithms');`;
+  const exportStatement = moduleSystem === "esm" ? "export default config;" : "module.exports = config;";
+  return `${importStatement}
+
+const generationAlgorithm = pathBasedConfigGenerator({
+    ignoreIncludesRootFolders: true,
+    removeBracketedFolders: true,
+    namespaceCase: 'kebab',
+    pathCase: 'camel',
+    clearOnDefaultNamespace: true,
+    ignoreFolders: ['core', 'utils', 'helpers']
+});
+
+/** @type {import('@lang-tag/cli/config').LangTagCLIConfig} */
 const config = {
     tagName: 'lang',
     isLibrary: false,
     includes: ['src/**/*.{js,ts,jsx,tsx}'],
     excludes: ['node_modules', 'dist', 'build', '**/*.test.ts'],
     outputDir: 'public/locales/en',
-    onConfigGeneration: (params) => {
+    onConfigGeneration: async event => {
         // We do not modify imported configurations
-        if (params.isImportedLibrary) return undefined;
-
-        //if (!params.config.path) {
-        //    params.config.path = 'test';
-        //    params.config.namespace = 'testNamespace';
-        //}
+        if (event.isImportedLibrary) return;
 
-        return undefined
+        if (event.config?.manual) return;
+        
+        await generationAlgorithm(event);
     },
     collect: {
         defaultNamespace: 'common',

package/index.js

@@ -23,6 +23,7 @@ class $LT_TagProcessor {
     const optionalVariableAssignment = `(?:\\s*(\\w+)\\s*=\\s*)?`;
     const matches = [];
     let currentIndex = 0;
+    const skipRanges = this.buildSkipRanges(fileContent);
     const startPattern = new RegExp(`${optionalVariableAssignment}${tagName}\\(\\s*\\{`, "g");
     while (true) {
       startPattern.lastIndex = currentIndex;
@@ -30,6 +31,10 @@ class $LT_TagProcessor {
       if (!startMatch) break;
       const matchStartIndex = startMatch.index;
       const variableName = startMatch[1] || void 0;
+      if (this.isInSkipRange(matchStartIndex, skipRanges)) {
+        currentIndex = matchStartIndex + 1;
+        continue;
+      }
       let braceCount = 1;
       let i = matchStartIndex + startMatch[0].length;
       while (i < fileContent.length && braceCount > 0) {
@@ -95,17 +100,29 @@ class $LT_TagProcessor {
       let validity = "ok";
       let parameter1 = void 0;
       let parameter2 = void 0;
+      if (this.hasTemplateInterpolation(parameter1Text) || parameter2Text && this.hasTemplateInterpolation(parameter2Text)) {
+        currentIndex = matchStartIndex + 1;
+        continue;
+      }
       try {
         parameter1 = JSON5.parse(parameter1Text);
         if (parameter2Text) {
           try {
             parameter2 = JSON5.parse(parameter2Text);
           } catch (error) {
-            validity = "invalid-param-2";
+            try {
+              parameter2 = JSON5.parse(this.escapeNewlinesInStrings(parameter2Text));
+            } catch {
+              validity = "invalid-param-2";
+            }
           }
         }
       } catch (error) {
-        validity = "invalid-param-1";
+        try {
+          parameter1 = JSON5.parse(this.escapeNewlinesInStrings(parameter1Text));
+        } catch {
+          validity = "invalid-param-1";
+        }
       }
       let parameterTranslations = this.config.translationArgPosition === 1 ? parameter1 : parameter2;
       let parameterConfig = this.config.translationArgPosition === 1 ? parameter2 : parameter1;
@@ -171,6 +188,180 @@ class $LT_TagProcessor {
     });
     return fileContent;
   }
+  buildSkipRanges(fileContent) {
+    const ranges = [];
+    let i = 0;
+    while (i < fileContent.length) {
+      const char = fileContent[i];
+      const nextChar = fileContent[i + 1];
+      if (char === "/" && nextChar === "/") {
+        const start = i;
+        i += 2;
+        while (i < fileContent.length && fileContent[i] !== "\n") {
+          i++;
+        }
+        ranges.push([start, i]);
+        continue;
+      }
+      if (char === "/" && nextChar === "*") {
+        const start = i;
+        i += 2;
+        while (i < fileContent.length - 1) {
+          if (fileContent[i] === "*" && fileContent[i + 1] === "/") {
+            i += 2;
+            break;
+          }
+          i++;
+        }
+        ranges.push([start, i]);
+        continue;
+      }
+      if (char === "'") {
+        const start = i;
+        i++;
+        while (i < fileContent.length) {
+          if (fileContent[i] === "\\") {
+            i += 2;
+            continue;
+          }
+          if (fileContent[i] === "'") {
+            i++;
+            break;
+          }
+          i++;
+        }
+        ranges.push([start, i]);
+        continue;
+      }
+      if (char === '"') {
+        const start = i;
+        i++;
+        while (i < fileContent.length) {
+          if (fileContent[i] === "\\") {
+            i += 2;
+            continue;
+          }
+          if (fileContent[i] === '"') {
+            i++;
+            break;
+          }
+          i++;
+        }
+        ranges.push([start, i]);
+        continue;
+      }
+      if (char === "`") {
+        const start = i;
+        i++;
+        while (i < fileContent.length) {
+          if (fileContent[i] === "\\") {
+            i += 2;
+            continue;
+          }
+          if (fileContent[i] === "`") {
+            i++;
+            break;
+          }
+          i++;
+        }
+        ranges.push([start, i]);
+        continue;
+      }
+      i++;
+    }
+    return ranges;
+  }
+  isInSkipRange(position, skipRanges) {
+    for (const [start, end] of skipRanges) {
+      if (position >= start && position < end) {
+        return true;
+      }
+    }
+    return false;
+  }
+  hasTemplateInterpolation(text) {
+    let i = 0;
+    while (i < text.length) {
+      if (text[i] === "`") {
+        i++;
+        while (i < text.length) {
+          if (text[i] === "\\") {
+            i += 2;
+            continue;
+          }
+          if (text[i] === "$" && text[i + 1] === "{") {
+            return true;
+          }
+          if (text[i] === "`") {
+            i++;
+            break;
+          }
+          i++;
+        }
+        continue;
+      }
+      i++;
+    }
+    return false;
+  }
+  escapeNewlinesInStrings(text) {
+    let result = "";
+    let i = 0;
+    while (i < text.length) {
+      const char = text[i];
+      if (char === '"') {
+        result += char;
+        i++;
+        while (i < text.length) {
+          if (text[i] === "\\") {
+            result += text[i] + text[i + 1];
+            i += 2;
+            continue;
+          }
+          if (text[i] === "\n") {
+            result += "\\n";
+            i++;
+            continue;
+          }
+          if (text[i] === '"') {
+            result += text[i];
+            i++;
+            break;
+          }
+          result += text[i];
+          i++;
+        }
+        continue;
+      }
+      if (char === "'") {
+        result += char;
+        i++;
+        while (i < text.length) {
+          if (text[i] === "\\") {
+            result += text[i] + text[i + 1];
+            i += 2;
+            continue;
+          }
+          if (text[i] === "\n") {
+            result += "\\n";
+            i++;
+            continue;
+          }
+          if (text[i] === "'") {
+            result += text[i];
+            i++;
+            break;
+          }
+          result += text[i];
+          i++;
+        }
+        continue;
+      }
+      result += char;
+      i++;
+    }
+    return result;
+  }
 }
 function getLineAndColumn(text, matchIndex) {
   const lines = text.slice(0, matchIndex).split("\n");
@@ -227,13 +418,20 @@ async function checkAndRegenerateFileLangTags(config, logger, file, path2) {
   }
   const replacements = [];
   for (let tag of tags) {
-    const newConfig = config.onConfigGeneration({
+    let newConfig = void 0;
+    let shouldUpdate = false;
+    await config.onConfigGeneration({
+      langTagConfig: config,
       config: tag.parameterConfig,
-      fullPath: file,
-      path: path2,
-      isImportedLibrary: path2.startsWith(libraryImportsDir)
+      absolutePath: file,
+      relativePath: path2,
+      isImportedLibrary: path2.startsWith(libraryImportsDir),
+      save: (updatedConfig) => {
+        newConfig = updatedConfig;
+        shouldUpdate = true;
+      }
     });
-    if (newConfig === void 0) {
+    if (!shouldUpdate) {
       continue;
     }
     if (JSON5.stringify(tag.parameterConfig) !== JSON5.stringify(newConfig)) {
@@ -284,7 +482,8 @@ const LANG_TAG_DEFAULT_CONFIG = {
   isLibrary: false,
   language: "en",
   translationArgPosition: 1,
-  onConfigGeneration: (params) => void 0
+  onConfigGeneration: async (event) => {
+  }
 };
 async function $LT_ReadConfig(projectPath) {
   const configPath = resolve(projectPath, CONFIG_FILE_NAME);
@@ -1079,6 +1278,11 @@ async function $LT_CMD_Collect(options) {
   const { config, logger } = await $LT_GetCommandEssentials();
   logger.info("Collecting translations from source files...");
   const files = await $LT_CollectCandidateFilesWithTags({ config, logger });
+  if (config.debug) {
+    for (let file of files) {
+      logger.debug("Found {count} translations tags inside: {file}", { count: file.tags.length, file: file.relativeFilePath });
+    }
+  }
   if (config.isLibrary) {
     await $LT_WriteAsExportFile({ config, logger, files });
     return;
@@ -1191,29 +1395,35 @@ async function detectModuleSystem() {
     return "cjs";
   }
 }
-function getExportStatement(moduleSystem) {
-  return moduleSystem === "esm" ? "export default config;" : "module.exports = config;";
-}
 async function generateDefaultConfig() {
   const moduleSystem = await detectModuleSystem();
-  const exportStatement = getExportStatement(moduleSystem);
-  return `/** @type {import('@lang-tag/cli/config').LangTagCLIConfig} */
+  const importStatement = moduleSystem === "esm" ? `import { pathBasedConfigGenerator } from '@lang-tag/cli/algorithms';` : `const { pathBasedConfigGenerator } = require('@lang-tag/cli/algorithms');`;
+  const exportStatement = moduleSystem === "esm" ? "export default config;" : "module.exports = config;";
+  return `${importStatement}
+
+const generationAlgorithm = pathBasedConfigGenerator({
+    ignoreIncludesRootFolders: true,
+    removeBracketedFolders: true,
+    namespaceCase: 'kebab',
+    pathCase: 'camel',
+    clearOnDefaultNamespace: true,
+    ignoreFolders: ['core', 'utils', 'helpers']
+});
+
+/** @type {import('@lang-tag/cli/config').LangTagCLIConfig} */
 const config = {
     tagName: 'lang',
     isLibrary: false,
     includes: ['src/**/*.{js,ts,jsx,tsx}'],
     excludes: ['node_modules', 'dist', 'build', '**/*.test.ts'],
     outputDir: 'public/locales/en',
-    onConfigGeneration: (params) => {
+    onConfigGeneration: async event => {
         // We do not modify imported configurations
-        if (params.isImportedLibrary) return undefined;
-
-        //if (!params.config.path) {
-        //    params.config.path = 'test';
-        //    params.config.namespace = 'testNamespace';
-        //}
+        if (event.isImportedLibrary) return;
 
-        return undefined
+        if (event.config?.manual) return;
+        
+        await generationAlgorithm(event);
     },
     collect: {
         defaultNamespace: 'common',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lang-tag/cli",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -22,6 +22,11 @@
     ".": {
       "import": "./index.js",
       "require": "./index.cjs"
+    },
+    "./algorithms": {
+      "types": "./algorithms/index.d.ts",
+      "import": "./algorithms/index.js",
+      "require": "./algorithms/index.cjs"
     }
   },
   "peerDependencies": {
@@ -29,6 +34,7 @@
   },
   "dependencies": {
     "acorn": "^8.15.0",
+    "case": "^1.6.3",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",
     "globby": "^14.1.0",