@remvst/localization 1.0.0

package/src/index.ts

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+import { hideBin } from 'yargs/helpers';
+import yargs from 'yargs';
+import { combineJsonCommand } from './commands/combine-json';
+import { googleTranslateCommand } from './commands/google-translate';
+import { parseCsvCommand } from './commands/parse-csv';
+import { toTypescriptCommand } from './commands/to-typescript';
+
+async function main() {
+    await yargs(hideBin(process.argv))
+        .command('parse-csv', 'convert a CSV into a JSON', async (yargs) => {
+            const argv = await yargs
+                .option('in', {
+                    type: 'string',
+                    alias: 'i',
+                    describe: 'Path to CSV to read from',
+                })
+                .option('out', {
+                    type: 'string',
+                    alias: 'o',
+                    describe: 'Output file',
+                })
+                .option('languagesLineIndex', {
+                    type: 'number',
+                    alias: 'l',
+                    describe: 'Index of the row containing the languages',
+                })
+                .demandOption('in')
+                .demandOption('out')
+                .demandOption('languagesLineIndex')
+                .argv
+
+            await parseCsvCommand(argv);
+        })
+        .command('combine-json', 'combine multiple JSON files', async (yargs) => {
+            const argv = await yargs
+                .option('main', {
+                    type: 'string',
+                    alias: 'i',
+                    describe: 'JSON file to read from',
+                })
+                .option('out', {
+                    type: 'string',
+                    alias: 'o',
+                    describe: 'Output JSON file',
+                })
+                .option('fallbackLocale', {
+                    type: 'string',
+                    describe: 'Default locale to backfill translations',
+                    default: 'en',
+                })
+                .option('fallback', {
+                    type: 'string',
+                    alias: 'f',
+                    describe: 'Fallback JSON file to read from',
+                })
+                .option('locale', {
+                    type: 'string',
+                    alias: 'l',
+                    describe: 'Locale to include',
+                })
+                .array('fallback')
+                .array('locale')
+                .demandOption('main')
+                .demandOption('out')
+                .demandOption('locale')
+                .demandOption('fallback')
+                .argv
+
+            await combineJsonCommand(argv);
+        })
+        .command('to-typescript', 'converts a JSON file into a TypeScript file', async (yargs) => {
+            const argv = await yargs
+                .option('in', {
+                    type: 'string',
+                    alias: 'i',
+                    describe: 'JSON file to read from',
+                })
+                .options('out', {
+                    type: 'string',
+                    alias: 'o',
+                    describe: 'Output Typescript file',
+                })
+                .demandOption('in')
+                .demandOption('out')
+                .argv
+
+            await toTypescriptCommand(argv);
+        })
+        .command('google-translate', 'adds missing translations to a JSON file using Google translate', async (yargs) => {
+            const argv = await yargs
+                .option('in', {
+                    type: 'string',
+                    alias: 'i',
+                    describe: 'JSON file to read from',
+                })
+                .option('out', {
+                    type: 'string',
+                    alias: 'o',
+                    describe: 'Output JSON file',
+                })
+                .option('fallbackLocale', {
+                    type: 'string',
+                    describe: 'Default locale to backfill translations',
+                    default: 'en',
+                })
+                .option('locale', {
+                    type: 'string',
+                    alias: 'l',
+                    describe: 'Locale to include',
+                })
+                .array('fallback')
+                .array('locale')
+                .demandOption('in')
+                .demandOption('out')
+                .demandOption('locale')
+                .argv
+
+            await googleTranslateCommand(argv);
+        })
+        .argv;
+}
+
+main();

package/src/model/translation-set.ts

@@ -0,0 +1,119 @@
+export type Key = string;
+export type Locale = string;
+export type LocalizedItem = Map<Locale, string>;
+
+export class TranslationSet {
+
+    private readonly locales = new Set<Locale>();
+    private readonly translations = new Map<Key, LocalizedItem>();
+
+    add(
+        key: Key,
+        locale: Locale,
+        localization: string,
+    ) {
+        this.locales.add(locale);
+
+        if (!this.translations.has(key)) {
+            this.translations.set(key, new Map());
+        }
+
+        this.translations.get(key)!.set(locale, localization);
+    }
+
+    fromLocalization(
+        language: Locale,
+        localization: string,
+    ): LocalizedItem | null {
+        const search = localization.toLowerCase();
+        for (const localizedItem of this.translations.values()) {
+            if (localizedItem.get(language)?.toLowerCase() === search) {
+                return localizedItem;
+            }
+        }
+        return null;
+    }
+
+    toJSON() {
+        const res: {[key: string]: {[key: string]: string}} = {};
+        for (const [key, localizedItem] of this.translations.entries()) {
+            res[key] = {};
+            for (const [locale, translation] of localizedItem.entries()) {
+                res[key][locale] = translation;
+            }
+        }
+        return res;
+    }
+
+    static fromJSON(json: {[key: string]: {[key: string]: string}}): TranslationSet {
+        const res = new TranslationSet();
+        for (const [key, localizedItem] of Object.entries(json)) {
+            for (const [locale, translation] of Object.entries(localizedItem)) {
+                res.add(key, locale, translation);
+            }
+        }
+        return res;
+    }
+
+    toTypeScript(): string {
+        let generatedFileContent = '';
+
+        generatedFileContent += `export type Locale = ${Array.from(this.locales).map(key => JSON.stringify(key)).join(' | ')};\n\n`;
+        generatedFileContent += `export type LocalizedKey = ${Array.from(this.translations.keys()).map(key => JSON.stringify(key)).join(' | ')};\n\n`;
+        generatedFileContent += `export type LocalizationItem = {[key in Locale]?: string};\n\n`;
+
+        generatedFileContent += 'export const LOCALIZATION: {[key in LocalizedKey]: LocalizationItem} = {\n';
+
+        for (const [key, localizedItem] of this.translations.entries()) {
+            generatedFileContent += `    ${key}: {\n`;
+
+            for (const [locale, translation] of localizedItem.entries()) {
+                if (!translation) continue;
+                generatedFileContent += `        ${locale}: ${JSON.stringify(translation)},\n`;
+            }
+
+            generatedFileContent += `    },\n`;
+        }
+
+        generatedFileContent += '};\n\n';
+
+        generatedFileContent += `let LOCALE: Locale = 'en';\n\n`;
+
+        generatedFileContent += `export function setLocale(locale: string) {\n`;
+        generatedFileContent += `    LOCALE = locale.split('-')[0] as Locale\n`;
+        generatedFileContent += `}\n\n`;
+
+        generatedFileContent += `export function localize(key: LocalizedKey) {\n`;
+        generatedFileContent += `    const localizationItem: LocalizationItem = LOCALIZATION[key];\n`;
+        generatedFileContent += `    return localizationItem[LOCALE] || localizationItem.en;\n`;
+        generatedFileContent += `}\n`;
+
+        return generatedFileContent;
+    }
+
+    async applyFallbacks(
+        locales: Locale[],
+        fallback: (key: Key, locale: Locale, localizedItem: LocalizedItem) => Promise<string | null>,
+    ) {
+        for (const [key, localizedItem] of this.translations.entries()) {
+            for (const locale of locales) {
+                let translation = localizedItem.get(locale) || null;
+                if (translation) continue;
+
+                try {
+                    translation = await fallback(key, locale, localizedItem);
+                } catch (err) {
+                    console.error(err);
+                    continue;
+                }
+
+                if (!translation) {
+                    console.warn(`Unable to find fallback for ${key}`);
+                    continue;
+                }
+
+                this.add(key, locale, translation);
+            }
+        }
+    }
+}

package/test/localization.json

@@ -0,0 +1,9 @@
+{
+    "ok": { "en": "Okay" },
+    "confirm": { "en": "Confirm" },
+    "cancel": { "en": "Cancel" },
+    "back": { "en": "Back" },
+    "play": { "en": "Play" },
+    "time": { "en": "Time" },
+    "backToMainMenu": { "en": "Back To Main Menu", "fr": "Retour au menu principal" }
+}