@lang-tag/cli 0.15.0 → 0.16.0

package/index.js

@@ -4,13 +4,14 @@ import fs, { readFileSync, existsSync } from "fs";
 import { writeFile, readFile } from "fs/promises";
 import JSON5 from "json5";
 import * as path from "path";
-import path__default, { sep, join, dirname as dirname$1 } from "path";
+import path__default, { sep, join, dirname } from "path";
 import { globby } from "globby";
-import path$1, { resolve, dirname } from "pathe";
+import path$1, { resolve } from "pathe";
 import { pathToFileURL, fileURLToPath } from "url";
-import { N as NamespaceCollector, $ as $LT_ReadFileContent, a as $LT_ReadJSON, b as $LT_WriteJSON, c as $LT_EnsureDirectoryExists, d as $LT_WriteFileWithDirs } from "./namespace-collector-DCruv_PK.js";
+import "case";
 import * as process$1 from "node:process";
 import process__default from "node:process";
+import { f as flexibleImportAlgorithm, N as NamespaceCollector, $ as $LT_ReadFileContent, a as $LT_ReadJSON, b as $LT_WriteJSON, c as $LT_EnsureDirectoryExists, d as $LT_WriteFileWithDirs } from "./flexible-import-algorithm-C-S1c742.js";
 import * as acorn from "acorn";
 import micromatch from "micromatch";
 import chokidar from "chokidar";
@@ -479,7 +480,7 @@ function isConfigSame(c1, c2) {
   return false;
 }
 const CONFIG_FILE_NAME = ".lang-tag.config.js";
-const EXPORTS_FILE_NAME = ".lang-tag.exports.json";
+const EXPORTS_FILE_NAME = "lang-tags.json";
 const LANG_TAG_DEFAULT_CONFIG = {
   tagName: "lang",
   isLibrary: false,
@@ -508,12 +509,18 @@ const LANG_TAG_DEFAULT_CONFIG = {
   import: {
     dir: "src/lang-libraries",
     tagImportPath: 'import { lang } from "@/my-lang-tag-path"',
-    onImport: ({ importedRelativePath, fileGenerationData }, actions) => {
-      const exportIndex = (fileGenerationData.index || 0) + 1;
-      fileGenerationData.index = exportIndex;
-      actions.setFile(path$1.basename(importedRelativePath));
-      actions.setExportName(`translations${exportIndex}`);
-    }
+    onImport: flexibleImportAlgorithm({
+      filePath: {
+        includePackageInPath: true
+      }
+    })
+    // onImport: ({importedRelativePath, fileGenerationData}: LangTagCLIOnImportParams, actions)=> {
+    //     const exportIndex = (fileGenerationData.index || 0) + 1;
+    //     fileGenerationData.index = exportIndex;
+    //
+    //     actions.setFile(path.basename(importedRelativePath));
+    //     actions.setExportName(`translations${exportIndex}`);
+    // }
   },
   translationArgPosition: 1,
   onConfigGeneration: async (event) => {
@@ -1022,19 +1029,19 @@ function deepMergeTranslations(target, source) {
 async function $LT_WriteToCollections({ config, collections, logger, clean }) {
   await config.collect.collector.preWrite(clean);
   const changedCollections = [];
-  for (let namespace of Object.keys(collections)) {
-    if (!namespace) {
+  for (let collectionName of Object.keys(collections)) {
+    if (!collectionName) {
       continue;
     }
-    const filePath = await config.collect.collector.resolveCollectionFilePath(namespace);
+    const filePath = await config.collect.collector.resolveCollectionFilePath(collectionName);
     let originalJSON = {};
     try {
       originalJSON = await $LT_ReadJSON(filePath);
     } catch (e) {
-      await config.collect.collector.onMissingCollection(namespace);
+      await config.collect.collector.onMissingCollection(collectionName);
     }
-    if (deepMergeTranslations(originalJSON, collections[namespace])) {
-      changedCollections.push(namespace);
+    if (deepMergeTranslations(originalJSON, collections[collectionName])) {
+      changedCollections.push(collectionName);
       await $LT_WriteJSON(filePath, originalJSON);
     }
   }
@@ -1073,28 +1080,18 @@ async function $LT_WriteAsExportFile({ config, logger, files }) {
   if (!packageJson) {
     throw new Error("package.json not found");
   }
-  const langTagFiles = {};
-  for (const file of files) {
-    langTagFiles[file.relativeFilePath] = {
-      matches: file.tags.map((tag) => {
-        let T = config.translationArgPosition === 1 ? tag.parameter1Text : tag.parameter2Text;
-        let C = config.translationArgPosition === 1 ? tag.parameter2Text : tag.parameter1Text;
-        if (!T) T = "{}";
-        if (!C) C = "{}";
-        return {
-          translations: T,
-          config: C,
-          variableName: tag.variableName
-        };
-      })
-    };
-  }
-  const data = {
-    language: config.baseLanguageCode,
-    packageName: packageJson.name || "",
-    files: langTagFiles
+  const exportData = {
+    baseLanguageCode: config.baseLanguageCode,
+    files: files.map(({ relativeFilePath, tags }) => ({
+      relativeFilePath,
+      tags: tags.map((tag) => ({
+        variableName: tag.variableName,
+        config: tag.parameterConfig,
+        translations: tag.parameterTranslations
+      }))
+    }))
   };
-  await $LT_WriteJSON(EXPORTS_FILE_NAME, data);
+  await writeFile(EXPORTS_FILE_NAME, JSON.stringify(exportData), "utf-8");
   logger.success(`Written {file}`, { file: EXPORTS_FILE_NAME });
 }
 async function $LT_GroupTagsToCollections({ logger, files, config }) {
@@ -1465,97 +1462,171 @@ async function $LT_CMD_InitConfig() {
     logger.error(error?.message);
   }
 }
-function $LT_CollectNodeModulesExportFilePaths(logger) {
+async function $LT_CollectExportFiles(logger) {
   const nodeModulesPath = path$1.join(process__default.cwd(), "node_modules");
   if (!fs.existsSync(nodeModulesPath)) {
     logger.error('"node_modules" directory not found');
     return [];
   }
-  function findExportJson(dir, depth = 0, maxDepth = 3) {
-    if (depth > maxDepth) return [];
-    let results = [];
-    try {
-      const files = fs.readdirSync(dir);
-      for (const file of files) {
-        const fullPath = path$1.join(dir, file);
-        const stat = fs.statSync(fullPath);
-        if (stat.isDirectory()) {
-          results = results.concat(findExportJson(fullPath, depth + 1, maxDepth));
-        } else if (file === EXPORTS_FILE_NAME) {
-          results.push(fullPath);
-        }
+  const results = [];
+  try {
+    const exportFiles = await globby([
+      `node_modules/**/${EXPORTS_FILE_NAME}`
+    ], {
+      cwd: process__default.cwd(),
+      onlyFiles: true,
+      ignore: ["**/node_modules/**/node_modules/**"],
+      deep: 4
+    });
+    for (const exportFile of exportFiles) {
+      const fullExportPath = path$1.resolve(exportFile);
+      const packageJsonPath = findPackageJsonForExport(fullExportPath, nodeModulesPath);
+      if (packageJsonPath) {
+        results.push({
+          exportPath: fullExportPath,
+          packageJsonPath
+        });
+      } else {
+        logger.warn("Found export file but could not match package.json: {exportPath}", {
+          exportPath: fullExportPath
+        });
       }
-    } catch (error) {
-      logger.error('Error reading directory "{dir}": {error}', {
-        dir,
-        error: String(error)
-      });
     }
-    return results;
+    logger.debug("Found {count} export files with matching package.json in node_modules", {
+      count: results.length
+    });
+  } catch (error) {
+    logger.error("Error scanning node_modules with globby: {error}", {
+      error: String(error)
+    });
   }
-  return findExportJson(nodeModulesPath);
+  return results;
 }
-async function $LT_ImportLibraries(config, logger) {
-  const files = $LT_CollectNodeModulesExportFilePaths(logger);
-  const generationFiles = {};
-  for (const filePath of files) {
-    const exportData = await $LT_ReadJSON(filePath);
-    for (let langTagFilePath in exportData.files) {
-      const fileGenerationData = {};
-      const matches = exportData.files[langTagFilePath].matches;
-      for (let match of matches) {
-        let parsedTranslations = typeof match.translations === "string" ? JSON5.parse(match.translations) : match.translations;
-        let parsedConfig = typeof match.config === "string" ? JSON5.parse(match.config) : match.config === void 0 ? {} : match.config;
-        let file = langTagFilePath;
-        let exportName = match.variableName || "";
-        config.import.onImport({
-          packageName: exportData.packageName,
-          importedRelativePath: langTagFilePath,
-          originalExportName: match.variableName,
-          translations: parsedTranslations,
-          config: parsedConfig,
-          fileGenerationData
-        }, {
-          setFile: (f) => {
-            file = f;
-          },
-          setExportName: (name) => {
-            exportName = name;
-          },
-          setConfig: (newConfig) => {
-            parsedConfig = newConfig;
-          }
-        });
-        if (!file || !exportName) {
-          throw new Error(`[lang-tag] onImport did not set fileName or exportName for package: ${exportData.packageName}, file: '${file}' (original: '${langTagFilePath}'), exportName: '${exportName}' (original: ${match.variableName})`);
-        }
-        let exports = generationFiles[file];
-        if (!exports) {
-          exports = {};
-          generationFiles[file] = exports;
-        }
-        const param1 = config.translationArgPosition === 1 ? parsedTranslations : parsedConfig;
-        const param2 = config.translationArgPosition === 1 ? parsedConfig : parsedTranslations;
-        exports[exportName] = `${config.tagName}(${JSON5.stringify(param1, void 0, 4)}, ${JSON5.stringify(param2, void 0, 4)})`;
+function findPackageJsonForExport(exportPath, nodeModulesPath) {
+  const relativePath = path$1.relative(nodeModulesPath, exportPath);
+  const pathParts = relativePath.split(path$1.sep);
+  if (pathParts.length < 2) {
+    return null;
+  }
+  if (pathParts[0].startsWith("@")) {
+    if (pathParts.length >= 3) {
+      const packageDir = path$1.join(nodeModulesPath, pathParts[0], pathParts[1]);
+      const packageJsonPath = path$1.join(packageDir, "package.json");
+      if (fs.existsSync(packageJsonPath)) {
+        return packageJsonPath;
       }
     }
+  } else {
+    const packageDir = path$1.join(nodeModulesPath, pathParts[0]);
+    const packageJsonPath = path$1.join(packageDir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      return packageJsonPath;
+    }
   }
-  for (let fileName of Object.keys(generationFiles)) {
+  return null;
+}
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const templatePath = join(__dirname, "templates", "import", "imported-tag.mustache");
+const template = readFileSync(templatePath, "utf-8");
+function renderTemplate$1(data) {
+  return mustache.render(template, data, {}, { escape: (text) => text });
+}
+async function generateImportFiles(config, logger, importManager) {
+  const importedFiles = importManager.getImportedFiles();
+  for (const importedFile of importedFiles) {
     const filePath = resolve(
       process$1.cwd(),
       config.import.dir,
-      fileName
+      importedFile.pathRelativeToImportDir
     );
-    const exports = Object.entries(generationFiles[fileName]).map(([name, tag]) => {
-      return `export const ${name} = ${tag};`;
-    }).join("\n\n");
-    const content = `${config.import.tagImportPath}
-
-${exports}`;
+    const processedExports = importedFile.tags.map((tag) => {
+      const parameter1 = config.translationArgPosition === 1 ? tag.translations : tag.config;
+      const parameter2 = config.translationArgPosition === 1 ? tag.config : tag.translations;
+      const hasParameter2 = parameter2 !== null && parameter2 !== void 0 && (typeof parameter2 !== "object" || Object.keys(parameter2).length > 0);
+      return {
+        name: tag.variableName,
+        parameter1: JSON5.stringify(parameter1, void 0, 4),
+        parameter2: hasParameter2 ? JSON5.stringify(parameter2, void 0, 4) : null,
+        hasParameter2,
+        config: {
+          tagName: config.tagName
+        }
+      };
+    });
+    const templateData = {
+      tagImportPath: config.import.tagImportPath,
+      exports: processedExports
+    };
+    const content = renderTemplate$1(templateData);
     await $LT_EnsureDirectoryExists(dirname(filePath));
     await writeFile(filePath, content, "utf-8");
-    logger.success('Imported node_modules file: "{fileName}"', { fileName });
+    logger.success('Created tag file: "{file}"', { file: importedFile.pathRelativeToImportDir });
+  }
+}
+class ImportManager {
+  importedFiles = [];
+  constructor() {
+    this.importedFiles = [];
+  }
+  importTag(pathRelativeToImportDir, tag) {
+    if (!pathRelativeToImportDir) {
+      throw new Error(`pathRelativeToImportDir required, got: ${pathRelativeToImportDir}`);
+    }
+    if (!tag?.variableName) {
+      throw new Error(`tag.variableName required, got: ${tag?.variableName}`);
+    }
+    if (!this.isValidJavaScriptIdentifier(tag.variableName)) {
+      throw new Error(`Invalid JavaScript identifier: "${tag.variableName}". Variable names must start with a letter, underscore, or dollar sign, and contain only letters, digits, underscores, and dollar signs.`);
+    }
+    if (tag.translations == null) {
+      throw new Error(`tag.translations required`);
+    }
+    let importedFile = this.importedFiles.find(
+      (file) => file.pathRelativeToImportDir === pathRelativeToImportDir
+    );
+    if (importedFile) {
+      const duplicateTag = importedFile.tags.find(
+        (existingTag) => existingTag.variableName === tag.variableName
+      );
+      if (duplicateTag) {
+        throw new Error(`Duplicate variable name "${tag.variableName}" in file "${pathRelativeToImportDir}". Variable names must be unique within the same file.`);
+      }
+    }
+    if (!importedFile) {
+      importedFile = { pathRelativeToImportDir, tags: [] };
+      this.importedFiles.push(importedFile);
+    }
+    importedFile.tags.push(tag);
+  }
+  getImportedFiles() {
+    return [...this.importedFiles];
+  }
+  getImportedFilesCount() {
+    return this.importedFiles.length;
   }
+  hasImportedFiles() {
+    return this.importedFiles.length > 0;
+  }
+  isValidJavaScriptIdentifier(name) {
+    return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+  }
+}
+async function $LT_ImportLibraries(config, logger) {
+  const exportFiles = await $LT_CollectExportFiles(logger);
+  const importManager = new ImportManager();
+  let exports = [];
+  for (const { exportPath, packageJsonPath } of exportFiles) {
+    const exportData = await $LT_ReadJSON(exportPath);
+    const packageJSON = await $LT_ReadJSON(packageJsonPath);
+    exports.push({ packageJSON, exportData });
+  }
+  config.import.onImport({ exports, importManager, logger, langTagConfig: config });
+  if (!importManager.hasImportedFiles()) {
+    logger.warn("No tags were imported from any library files");
+    return;
+  }
+  await generateImportFiles(config, logger, importManager);
   if (config.import.onImportFinish) config.import.onImportFinish();
 }
 async function $LT_ImportTranslations() {
@@ -1565,15 +1636,15 @@ async function $LT_ImportTranslations() {
   await $LT_ImportLibraries(config, logger);
   logger.success("Successfully imported translations from libraries.");
 }
-function renderTemplate(template, data) {
-  return mustache.render(template, data, {}, { escape: (text) => text });
+function renderTemplate(template2, data) {
+  return mustache.render(template2, data, {}, { escape: (text) => text });
 }
 function loadTemplate(templateName) {
-  const __filename = fileURLToPath(import.meta.url);
-  const __dirname = dirname$1(__filename);
-  const templatePath = join(__dirname, "template", `${templateName}.mustache`);
+  const __filename2 = fileURLToPath(import.meta.url);
+  const __dirname2 = dirname(__filename2);
+  const templatePath2 = join(__dirname2, "templates", "tag", `${templateName}.mustache`);
   try {
-    return readFileSync(templatePath, "utf-8");
+    return readFileSync(templatePath2, "utf-8");
   } catch (error) {
     throw new Error(`Failed to load template ${templateName}: ${error}`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lang-tag/cli",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/templates/config/init-config.mustache

@@ -0,0 +1 @@
+-

package/templates/import/imported-tag.mustache

@@ -0,0 +1,14 @@
+/**
+ * Imported library translations
+ * 
+ * You can modify these translations as needed. On next import:
+ * - Your changes will be preserved ( for now only translations values are preserved )
+ * - New translations will be added
+ * - Unused translations will be commented out
+ */
+{{tagImportPath}}
+
+{{#exports}}
+export const {{name}} = {{config.tagName}}({{parameter1}}{{#hasParameter2}}, {{parameter2}}{{/hasParameter2}});
+
+{{/exports}}

package/namespace-collector-DCruv_PK.js

@@ -1,95 +0,0 @@
-import { mkdir, writeFile, readFile, rm } from "fs/promises";
-import { dirname, resolve } from "path";
-import path, { resolve as resolve$1 } from "pathe";
-import process__default from "node:process";
-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
-    });
-  }
-}
-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
-};

package/namespace-collector-DRnZvkDR.cjs

@@ -1,94 +0,0 @@
-"use strict";
-const promises = require("fs/promises");
-const path = require("path");
-const path$1 = require("pathe");
-const process$1 = require("node:process");
-class TranslationsCollector {
-  config;
-  logger;
-}
-async function $LT_EnsureDirectoryExists(filePath) {
-  await promises.mkdir(filePath, { recursive: true });
-}
-async function $LT_RemoveDirectory(dirPath) {
-  try {
-    await promises.rm(dirPath, { recursive: true, force: true });
-  } catch (error) {
-  }
-}
-async function $LT_RemoveFile(filePath) {
-  try {
-    await promises.rm(filePath, { force: true });
-  } catch (error) {
-  }
-}
-async function $LT_WriteJSON(filePath, data) {
-  await promises.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
-}
-async function $LT_ReadJSON(filePath) {
-  const content = await promises.readFile(filePath, "utf-8");
-  return JSON.parse(content);
-}
-async function $LT_WriteFileWithDirs(filePath, content) {
-  const dir = path.dirname(filePath);
-  try {
-    await promises.mkdir(dir, { recursive: true });
-  } catch (error) {
-  }
-  await promises.writeFile(filePath, content, "utf-8");
-}
-async function $LT_ReadFileContent(relativeFilePath) {
-  const cwd = process.cwd();
-  const absolutePath = path.resolve(cwd, relativeFilePath);
-  return await promises.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$1.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 path$1.resolve(
-      process$1.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
-    });
-  }
-}
-exports.$LT_EnsureDirectoryExists = $LT_EnsureDirectoryExists;
-exports.$LT_ReadFileContent = $LT_ReadFileContent;
-exports.$LT_ReadJSON = $LT_ReadJSON;
-exports.$LT_RemoveFile = $LT_RemoveFile;
-exports.$LT_WriteFileWithDirs = $LT_WriteFileWithDirs;
-exports.$LT_WriteJSON = $LT_WriteJSON;
-exports.NamespaceCollector = NamespaceCollector;
-exports.TranslationsCollector = TranslationsCollector;