@scoutello/i18n-magic 0.18.0 → 0.20.0

package/src/lib/utils.ts

@@ -5,7 +5,7 @@ import path from "node:path"
 import type OpenAI from "openai"
 import prompts from "prompts"
 import { languages } from "./languges"
-import type { Configuration } from "./types"
+import type { Configuration, GlobPatternConfig } from "./types"
 
 export const loadConfig = ({
   configPath = "i18n-magic.js",
@@ -180,33 +180,145 @@ export const getPureKey = (
   return null
 }
 
-export const getMissingKeys = async ({
+/**
+ * Extracts all glob patterns from the configuration, handling both string and object formats
+ */
+export const extractGlobPatterns = (
+  globPatterns: (string | GlobPatternConfig)[],
+): string[] => {
+  return globPatterns.map((pattern) =>
+    typeof pattern === "string" ? pattern : pattern.pattern,
+  )
+}
+
+/**
+ * Gets the namespaces associated with a specific file path based on glob pattern configuration
+ */
+export const getNamespacesForFile = (
+  filePath: string,
+  globPatterns: (string | { pattern: string; namespaces: string[] })[],
+  defaultNamespace: string,
+): string[] => {
+  const matchingNamespaces: string[] = []
+
+  for (const pattern of globPatterns) {
+    if (typeof pattern === "object") {
+      // Use minimatch or similar logic to check if file matches pattern
+      const globPattern = pattern.pattern
+      // For now, using a simple includes check - in production you'd want proper glob matching
+      if (filePath.includes(globPattern.replace("**/*", "").replace("*", ""))) {
+        matchingNamespaces.push(...pattern.namespaces)
+      }
+    }
+  }
+
+  // If no specific namespaces found, use default namespace
+  return matchingNamespaces.length > 0
+    ? [...new Set(matchingNamespaces)]
+    : [defaultNamespace]
+}
+
+/**
+ * Gets all glob patterns that should be used for a specific namespace
+ */
+export const getGlobPatternsForNamespace = (
+  namespace: string,
+  globPatterns: (string | { pattern: string; namespaces: string[] })[],
+): string[] => {
+  const patterns: string[] = []
+
+  for (const pattern of globPatterns) {
+    if (typeof pattern === "string") {
+      // String patterns apply to all namespaces
+      patterns.push(pattern)
+    } else if (pattern.namespaces.includes(namespace)) {
+      // Object patterns only apply to specified namespaces
+      patterns.push(pattern.pattern)
+    }
+  }
+
+  return patterns
+}
+
+/**
+ * Extracts keys with their associated namespaces based on the files they're found in
+ */
+export const getKeysWithNamespaces = async ({
   globPatterns,
-  namespaces,
   defaultNamespace,
-  defaultLocale,
-  loadPath,
-}: Configuration) => {
+}: Pick<Configuration, "globPatterns" | "defaultNamespace">) => {
   const parser = new Parser({
     nsSeparator: false,
     keySeparator: false,
   })
 
-  const files = await glob([...globPatterns, "!**/node_modules/**"])
+  const allPatterns = extractGlobPatterns(globPatterns)
+  const files = await glob([...allPatterns, "!**/node_modules/**"])
 
-  const keys = []
+  const keysWithNamespaces: Array<{
+    key: string
+    namespaces: string[]
+    file: string
+  }> = []
 
   for (const file of files) {
     const content = fs.readFileSync(file, "utf-8")
+    const fileKeys: string[] = []
+
     parser.parseFuncFromString(content, { list: ["t"] }, (key: string) => {
-      keys.push(key)
+      fileKeys.push(key)
     })
+
+    // Get namespaces for this file
+    const fileNamespaces = getNamespacesForFile(
+      file,
+      globPatterns,
+      defaultNamespace,
+    )
+
+    // Add each key with its associated namespaces
+    for (const key of fileKeys) {
+      keysWithNamespaces.push({
+        key,
+        namespaces: fileNamespaces,
+        file,
+      })
+    }
   }
 
-  const uniqueKeys = removeDuplicatesFromArray(keys)
+  return keysWithNamespaces
+}
 
+export const getMissingKeys = async ({
+  globPatterns,
+  namespaces,
+  defaultNamespace,
+  defaultLocale,
+  loadPath,
+}: Configuration) => {
+  const keysWithNamespaces = await getKeysWithNamespaces({
+    globPatterns,
+    defaultNamespace,
+  })
   const newKeys = []
 
+  // Group keys by namespace
+  const keysByNamespace: Record<string, Set<string>> = {}
+
+  for (const { key, namespaces: keyNamespaces } of keysWithNamespaces) {
+    for (const namespace of keyNamespaces) {
+      if (!keysByNamespace[namespace]) {
+        keysByNamespace[namespace] = new Set()
+      }
+
+      const pureKey = getPureKey(key, namespace, namespace === defaultNamespace)
+      if (pureKey) {
+        keysByNamespace[namespace].add(pureKey)
+      }
+    }
+  }
+
+  // Check for missing keys in each namespace
   for (const namespace of namespaces) {
     const existingKeys = await loadLocalesFile(
       loadPath,
@@ -214,17 +326,13 @@ export const getMissingKeys = async ({
       namespace,
     )
 
-    console.log(Object.keys(existingKeys).length, "existing keys")
+    console.log(Object.keys(existingKeys).length, "existing keys in", namespace)
 
-    for (const key of uniqueKeys) {
-      const pureKey = getPureKey(key, namespace, namespace === defaultNamespace)
-
-      if (!pureKey) {
-        continue
-      }
+    const keysForNamespace = keysByNamespace[namespace] || new Set()
 
-      if (!existingKeys[pureKey]) {
-        newKeys.push({ key: pureKey, namespace })
+    for (const key of keysForNamespace) {
+      if (!existingKeys[key]) {
+        newKeys.push({ key, namespace })
       }
     }
   }

package/src/commands/create-pruned-namespace-automated.ts

@@ -1,165 +0,0 @@
-import glob from "fast-glob"
-import { Parser } from "i18next-scanner"
-import fs from "node:fs"
-import type { Configuration } from "../lib/types"
-import {
-  getPureKey,
-  loadLocalesFile,
-  removeDuplicatesFromArray,
-  writeLocalesFile,
-} from "../lib/utils"
-
-export interface PruneOptions {
-  sourceNamespace: string
-  newNamespace: string
-  globPatterns: string[]
-}
-
-export interface PruneResult {
-  locale: string
-  keyCount: number
-  success: boolean
-  error?: string
-}
-
-export interface PruneResponse {
-  success: boolean
-  message: string
-  keysCount: number
-  results?: PruneResult[]
-}
-
-export const createPrunedNamespaceAutomated = async (
-  config: Configuration,
-  options: PruneOptions,
-): Promise<PruneResponse> => {
-  const { namespaces, loadPath, savePath, locales, defaultNamespace } = config
-  const { sourceNamespace, newNamespace, globPatterns } = options
-
-  // Validate inputs
-  if (!namespaces.includes(sourceNamespace)) {
-    throw new Error(
-      `Source namespace '${sourceNamespace}' not found in configuration`,
-    )
-  }
-
-  if (namespaces.includes(newNamespace)) {
-    throw new Error(`Namespace '${newNamespace}' already exists`)
-  }
-
-  console.log(
-    `Creating pruned namespace '${newNamespace}' from '${sourceNamespace}'`,
-  )
-  console.log(`Using glob patterns: ${globPatterns.join(", ")}`)
-
-  // Extract keys from files matching the glob patterns
-  const parser = new Parser({
-    nsSeparator: false,
-    keySeparator: false,
-  })
-
-  const files = await glob([...globPatterns, "!**/node_modules/**"])
-  console.log(`Found ${files.length} files to scan`)
-
-  const extractedKeys = []
-
-  for (const file of files) {
-    const content = fs.readFileSync(file, "utf-8")
-    parser.parseFuncFromString(content, { list: ["t"] }, (key: string) => {
-      extractedKeys.push(key)
-    })
-  }
-
-  const uniqueExtractedKeys = removeDuplicatesFromArray(extractedKeys)
-  console.log(`Found ${uniqueExtractedKeys.length} unique translation keys`)
-
-  // Filter keys that belong to the source namespace
-  const relevantKeys = []
-
-  for (const key of uniqueExtractedKeys) {
-    const pureKey = getPureKey(
-      key,
-      sourceNamespace,
-      sourceNamespace === defaultNamespace,
-    )
-
-    if (pureKey) {
-      relevantKeys.push(pureKey)
-    }
-  }
-
-  console.log(
-    `Found ${relevantKeys.length} keys from namespace '${sourceNamespace}'`,
-  )
-
-  if (relevantKeys.length === 0) {
-    console.log("No relevant keys found. Exiting...")
-    return {
-      success: false,
-      message: "No relevant keys found",
-      keysCount: 0,
-    }
-  }
-
-  // Get translations from source namespace and create new namespace files
-  const results: PruneResult[] = []
-
-  for (const locale of locales) {
-    try {
-      // Load source namespace translations
-      const sourceTranslations = await loadLocalesFile(
-        loadPath,
-        locale,
-        sourceNamespace,
-      )
-
-      // Create new namespace with only the keys used in the glob pattern files
-      const newNamespaceTranslations: Record<string, string> = {}
-
-      for (const key of relevantKeys) {
-        if (sourceTranslations[key]) {
-          newNamespaceTranslations[key] = sourceTranslations[key]
-        }
-      }
-
-      // Write the new namespace file
-      await writeLocalesFile(
-        savePath,
-        locale,
-        newNamespace,
-        newNamespaceTranslations,
-      )
-
-      const keyCount = Object.keys(newNamespaceTranslations).length
-      console.log(
-        `Created pruned namespace '${newNamespace}' for locale '${locale}' with ${keyCount} keys`,
-      )
-
-      results.push({
-        locale,
-        keyCount,
-        success: true,
-      })
-    } catch (error) {
-      console.error(
-        `Error creating pruned namespace for locale '${locale}':`,
-        error,
-      )
-      results.push({
-        locale,
-        keyCount: 0,
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-      })
-    }
-  }
-
-  console.log(`✅ Successfully created pruned namespace '${newNamespace}'`)
-
-  return {
-    success: true,
-    message: `Created pruned namespace '${newNamespace}' with ${relevantKeys.length} keys`,
-    keysCount: relevantKeys.length,
-    results,
-  }
-}

package/src/commands/create-pruned-namespace.ts

@@ -1,165 +0,0 @@
-import glob from "fast-glob"
-import { Parser } from "i18next-scanner"
-import fs from "node:fs"
-import prompts from "prompts"
-import type { Configuration } from "../lib/types"
-import {
-  getPureKey,
-  loadLocalesFile,
-  removeDuplicatesFromArray,
-  writeLocalesFile,
-} from "../lib/utils"
-
-export const createPrunedNamespace = async (config: Configuration) => {
-  const { namespaces, loadPath, savePath, locales, defaultNamespace } = config
-
-  // Step 1: Ask for source namespace
-  const sourceNamespaceResponse = await prompts({
-    type: "select",
-    name: "value",
-    message: "Select source namespace to create pruned version from:",
-    choices: namespaces.map((namespace) => ({
-      title: namespace,
-      value: namespace,
-    })),
-    onState: (state) => {
-      if (state.aborted) {
-        process.nextTick(() => {
-          process.exit(0)
-        })
-      }
-    },
-  })
-
-  const sourceNamespace = sourceNamespaceResponse.value
-
-  // Step 2: Ask for new namespace name
-  const newNamespaceResponse = await prompts({
-    type: "text",
-    name: "value",
-    message: "Enter the name for the new namespace:",
-    validate: (value) => {
-      if (!value) return "Namespace name cannot be empty"
-      if (namespaces.includes(value)) return "Namespace already exists"
-      return true
-    },
-    onState: (state) => {
-      if (state.aborted) {
-        process.nextTick(() => {
-          process.exit(0)
-        })
-      }
-    },
-  })
-
-  const newNamespace = newNamespaceResponse.value
-
-  // Step 3: Ask for glob patterns to find relevant keys
-  const globPatternsResponse = await prompts({
-    type: "list",
-    name: "value",
-    message: "Enter glob patterns to find relevant keys (comma separated):",
-    initial: config.globPatterns.join(","),
-    separator: ",",
-    onState: (state) => {
-      if (state.aborted) {
-        process.nextTick(() => {
-          process.exit(0)
-        })
-      }
-    },
-  })
-
-  const selectedGlobPatterns = globPatternsResponse.value
-
-  console.log(
-    `Finding keys used in files matching: ${selectedGlobPatterns.join(", ")}`,
-  )
-
-  // Extract keys from files matching the glob patterns
-  const parser = new Parser({
-    nsSeparator: false,
-    keySeparator: false,
-  })
-
-  const files = await glob([...selectedGlobPatterns, "!**/node_modules/**"])
-  console.log(`Found ${files.length} files to scan`)
-
-  const extractedKeys = []
-
-  for (const file of files) {
-    const content = fs.readFileSync(file, "utf-8")
-    parser.parseFuncFromString(content, { list: ["t"] }, (key: string) => {
-      extractedKeys.push(key)
-    })
-  }
-
-  const uniqueExtractedKeys = removeDuplicatesFromArray(extractedKeys)
-  console.log(`Found ${uniqueExtractedKeys.length} unique translation keys`)
-
-  // Filter keys that belong to the source namespace
-  const relevantKeys = []
-
-  for (const key of uniqueExtractedKeys) {
-    const pureKey = getPureKey(
-      key,
-      sourceNamespace,
-      sourceNamespace === defaultNamespace,
-    )
-
-    if (pureKey) {
-      relevantKeys.push(pureKey)
-    }
-  }
-
-  console.log(
-    `Found ${relevantKeys.length} keys from namespace '${sourceNamespace}'`,
-  )
-
-  if (relevantKeys.length === 0) {
-    console.log("No relevant keys found. Exiting...")
-    return
-  }
-
-  // Get translations from source namespace and create new namespace files
-  for (const locale of locales) {
-    try {
-      // Load source namespace translations
-      const sourceTranslations = await loadLocalesFile(
-        loadPath,
-        locale,
-        sourceNamespace,
-      )
-
-      // Create new namespace with only the keys used in the glob pattern files
-      const newNamespaceTranslations: Record<string, string> = {}
-
-      for (const key of relevantKeys) {
-        if (sourceTranslations[key]) {
-          newNamespaceTranslations[key] = sourceTranslations[key]
-        }
-      }
-
-      // Write the new namespace file
-      await writeLocalesFile(
-        savePath,
-        locale,
-        newNamespace,
-        newNamespaceTranslations,
-      )
-
-      console.log(
-        `Created pruned namespace '${newNamespace}' for locale '${locale}' with ${
-          Object.keys(newNamespaceTranslations).length
-        } keys`,
-      )
-    } catch (error) {
-      console.error(
-        `Error creating pruned namespace for locale '${locale}':`,
-        error,
-      )
-    }
-  }
-
-  console.log(`✅ Successfully created pruned namespace '${newNamespace}'`)
-}