gettext-universal 1.0.0

package/bin/gettext-universal.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+import Scanner from "../src/scanner.mjs"
+
+const processArgs = process.argv.slice(2)
+const extensions = []
+const files = []
+const ignores = []
+let directory, output
+
+for (let i = 0; i < processArgs.length; i++) {
+  const arg = processArgs[i]
+
+  if (arg == "--directory") {
+    directory = processArgs[++i]
+  } else if (arg == "--extension") {
+    extensions.push(processArgs[++i])
+  } else if (arg == "--files") {
+    while (i < processArgs.length - 1) {
+      const file = processArgs[++i]
+
+      if (!file) throw new Error("No file found?")
+
+      files.push(file)
+    }
+  } else if (arg == "--ignore") {
+    ignores.push(processArgs[++i])
+  } else if (arg == "--output") {
+    output = processArgs[++i]
+  } else {
+    throw new Error(`Unknown argument: ${arg}`)
+  }
+}
+
+if (extensions.length == 0) {
+  extensions.push(".js", ".cjs", ".mjs", ".jsx", ".tsx")
+}
+
+const scanner = new Scanner({directory, extensions, files, ignores, output})
+
+await scanner.scan()

package/bin/po2mjs.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+import Po2Mjs from "../src/po2mjs.mjs"
+
+const processArgs = process.argv.slice(2)
+let directory
+
+for (let i = 0; i < processArgs.length; i++) {
+  const arg = processArgs[i]
+
+  if (arg == "--directory") {
+    directory = processArgs[++i]
+  } else {
+    throw new Error(`Unknown argument: ${arg}`)
+  }
+}
+
+const po2Mjs = new Po2Mjs({directory})
+
+await po2Mjs.run()

package/package.json

@@ -0,0 +1,32 @@
+{
+  "bin": {
+    "gettext-universal": "bin/gettext-universal.mjs"
+  },
+  "name": "gettext-universal",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "gettext-universal": "node bin/gettext-universal.mjs",
+    "po2mjs": "node bin/po2mjs.mjs",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kaspernj/gettext-universal.git"
+  },
+  "keywords": [
+    "gettext",
+    "poedit",
+    "scan"
+  ],
+  "author": "kasper@diestoeckels.de",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/kaspernj/gettext-universal/issues"
+  },
+  "homepage": "https://github.com/kaspernj/gettext-universal#readme",
+  "description": "",
+  "dependencies": {
+    "diggerize": "^1.0.5"
+  }
+}

package/src/config.mjs

@@ -0,0 +1,28 @@
+class Config {
+  constructor() {
+    this.locales = {}
+  }
+
+  loadTranslationsFromRequireContext(requireContext) {
+    for (const localeFile of requireContext.keys()) {
+      const match = localeFile.match(/^\.\/([a-z]{2}).mjs$/)
+
+      if (!match) {
+        throw new Error(`Couldn't detect locale from file: ${localeFile}`)
+      }
+
+      const locale = match[1]
+      const translations = requireContext(localeFile).default
+
+      locales[locale] = translations
+    }
+  }
+
+  setFallbacks(fallbacks) {
+    this.fallbacks = fallbacks
+  }
+}
+
+const config = new Config()
+
+export default config

package/src/po2mjs.mjs

@@ -0,0 +1,43 @@
+import {promises as fs} from "fs"
+import path from "path"
+
+export default class Po2Mjs {
+  constructor({directory}) {
+    this.directory = directory
+  }
+
+  async run() {
+    const files = await fs.readdir(this.directory)
+
+    for (const file of files) {
+      const ext = path.extname(file).toLowerCase()
+
+      if (ext == ".po") {
+        await this.readFile(file, ext)
+      }
+    }
+  }
+
+  async readFile(file, ext) {
+    const fullPath = `${this.directory}/${file}`
+    const baseName = path.basename(file, ext)
+    const jsFilePath = `${this.directory}/${baseName}.mjs`
+    const fileContentBuffer = await fs.readFile(fullPath)
+    const fileContent = fileContentBuffer.toString()
+    const matches = fileContent.matchAll(/#: (.+?)\nmsgid \"(.+?)\"\nmsgstr \"(.+?)\"\n(\n|$)/g)
+    const translations = {}
+
+    for (const match of matches) {
+      const msgId = match[2]
+      const msgStr = match[3]
+
+      translations[msgId] = msgStr
+    }
+
+    const jsCode = `export default ${JSON.stringify(translations, null, 2)}\n`
+
+    await fs.writeFile(jsFilePath, jsCode)
+
+    console.log(`Wrote ${jsFilePath}`)
+  }
+}

package/src/scanner.mjs

@@ -0,0 +1,142 @@
+import {promises as fs} from "fs"
+import path from "path"
+
+export default class Scanner {
+  constructor({directory, extensions, files, ignores, output, ...restArgs}) {
+    if (Object.keys(restArgs).length > 0) throw new Error(`Unknown arrguments: ${Object.keys(restArgs).join(", ")}`)
+
+    this.directory = directory
+    this.extensions = extensions
+    this.files = files
+    this.ignores = ignores
+    this.output = output
+    this.scannedFiles = []
+    this.translations = {}
+  }
+
+  async scan() {
+    if (this.directory) {
+      await this.scanDir(this.directory, [])
+    } else if (this.files.length > 0) {
+      await this.scanGivenFiles()
+    } else {
+      throw new Error("No directory or files given to scan")
+    }
+
+    await this.scanFiles()
+
+    if (this.output) {
+      await this.writeOutput()
+    } else {
+      console.log({translations: this.translations})
+    }
+  }
+
+  async scanGivenFiles() {
+    for (const file of this.files) {
+      this.scannedFiles.push({
+        fullPath: file,
+        localPath: file,
+      })
+    }
+  }
+
+  async scanFiles() {
+    const promises = []
+
+    for (const fileData of this.scannedFiles) {
+      promises.push(this.scanFile(fileData))
+    }
+
+    await Promise.all(promises)
+  }
+
+  async scanFile({localPath, fullPath}) {
+    if (!fullPath) throw new Error(`Invalid fullPath given: ${fullPath}`)
+
+    const contentBuffer = await fs.readFile(fullPath)
+    const content = await contentBuffer.toString()
+    const lines = content.split(/(\r\n|\n)/)
+
+    for (let lineNumber = 1; lineNumber < lines.length; lineNumber++) {
+      const line = lines[lineNumber - 1]
+      const match = line.match(/_\(\s*("(.+?)"|'(.+?)')\s*(,|\))/)
+
+      if (match) {
+        const translationKey = match[2] || match[3]
+
+        if (!translationKey) throw new Error("Empty translation key from match", {match})
+
+        if (!(translationKey in this.translations)) {
+          this.translations[translationKey] = {
+            files: []
+          }
+        }
+
+        this.translations[translationKey].files.push({localPath, lineNumber})
+      }
+    }
+  }
+
+  async scanDir(pathToScan, pathParts) {
+    const files = await fs.readdir(pathToScan)
+    const localPath = pathParts.join("/")
+
+    if (this.ignores.includes(localPath)) {
+      // console.log(`Ignoreing ${localPath}`)
+
+      return
+    }
+
+    // console.log({files, path: pathParts.join("/")})
+
+    for (const file of files) {
+      const fullPath = `${pathToScan}/${file}`
+      const stat = await fs.lstat(fullPath)
+
+      if (stat.isDirectory()) {
+        const newPathParts = pathParts.concat([file])
+
+        this.scanDir(fullPath, newPathParts)
+      } else {
+        const ext = path.extname(file).toLowerCase()
+
+        if (this.extensions.includes(ext)) {
+          this.addScannedFile({fullPath, localPath: `${localPath}/${file}`})
+        }
+      }
+    }
+  }
+
+  addScannedFile({fullPath, localPath}) {
+    this.scannedFiles.push({
+      fullPath,
+      localPath,
+    })
+  }
+
+  async writeOutput() {
+    const fp = await fs.open(this.output, "w")
+
+    let translationsCount = 0
+
+    for (const translationKey in this.translations) {
+      const translation = this.translations[translationKey]
+
+      if (translationsCount >= 1) await fp.write("\n")
+
+      for (const file of translation.files) {
+        const {localPath, lineNumber} = file
+
+        await fp.write(`#: ${localPath}:${lineNumber}\n`)
+      }
+
+      await fp.write(`msgid \"${translationKey}\"\n`)
+      await fp.write("msgstr \"\"\n")
+
+      translationsCount++
+    }
+
+    await fp.close()
+  }
+}

package/src/use-translate.mjs

@@ -0,0 +1,48 @@
+import {useCallback} from "react"
+import {useLocales} from "expo-localization"
+
+const translate = (msgId, preferredLocales) => {
+  let translation
+
+  for (preferredLocale of preferredLocales) {
+    const localeTranslations = locales[preferredLocale]
+
+    if (!localeTranslations) continue
+
+    const localeTranslation = localeTranslations[msgId]
+
+    if (localeTranslation) {
+      translation = localeTranslation
+      break
+    }
+  }
+
+  if (!translation) {
+    for (const fallback of fallbacks) {
+      const localeTranslations = locales[fallback]
+
+      if (!localeTranslations) continue
+
+      const localeTranslation = localeTranslations[msgId]
+
+      if (localeTranslation) {
+        translation = localeTranslation
+        break
+      }
+    }
+  }
+
+  if (!translation) translation = msgId
+
+  return translation
+}
+
+const useTranslate = () => {
+  const locales = useLocales()
+  const preferredLocales = locales.map((localeData) => localeData.languageCode)
+  const currentTranslation = useCallback((msgId) => translate(msgId, preferredLocales), [preferredLocales])
+
+  return currentTranslation
+}
+
+export default useTranslate

package/test.po

@@ -0,0 +1,9 @@
+#: app/(tabs)/index.tsx:51
+#: app/sign-in.jsx:27
+msgid "Sign in"
+msgstr ""
+
+#: app/(tabs)/index.tsx:61
+#: app/sign-up.jsx:27
+msgid "Sign up"
+msgstr ""