@lang-tag/cli 0.16.0 → 0.18.0

package/flexible-import-algorithm-Fa-l4jWj.cjs

@@ -1,327 +0,0 @@
-"use strict";
-const promises = require("fs/promises");
-const path = require("path");
-const path$1 = require("pathe");
-const process$1 = require("node:process");
-const caseLib = require("case");
-const micromatch = require("micromatch");
-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 applyCaseTransform(str, caseType) {
-  if (caseType === "no") {
-    return str;
-  }
-  const caseFunction = caseLib__namespace[caseType];
-  if (typeof caseFunction === "function") {
-    return caseFunction(str);
-  }
-  return str;
-}
-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
-    });
-  }
-}
-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: exports2, importManager, logger } = event;
-    for (const { packageJSON, exportData } of exports2) {
-      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 ${path$1.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 ${path$1.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 path$1.join(transformedPackageName, transformedFilePath);
-    } else {
-      const transformedPackageName = applyCaseTransform(normalizedPackageName, caseType.directories || "no");
-      const transformedFilePath = applyCaseTransformToPath(originalFileName, caseType);
-      return path$1.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);
-}
-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;
-exports.applyCaseTransform = applyCaseTransform;
-exports.flexibleImportAlgorithm = flexibleImportAlgorithm;

package/templates/config/init-config.mustache

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