mapcomplete/UI/i18n/Translation.ts

160 lines
5.5 KiB
TypeScript
Raw Normal View History

2020-11-06 01:58:26 +01:00
import {UIElement} from "../UIElement";
import Combine from "../Base/Combine";
import Locale from "./Locale";
import {Utils} from "../../Utils";
export class Translation extends UIElement {
public static forcedLanguage = undefined;
2020-11-06 01:58:26 +01:00
2020-11-11 16:23:49 +01:00
public readonly translations: object
return
allIcons;
2020-11-11 16:23:49 +01:00
constructor(translations: object, context?: string) {
super(Locale.language)
if (translations === undefined) {
2020-11-11 16:23:49 +01:00
throw `Translation without content (${context})`
}
let count = 0;
for (const translationsKey in translations) {
count++;
2021-04-11 19:21:41 +02:00
if (typeof (translations[translationsKey]) != "string") {
throw "Error in an object depicting a translation: a non-string object was found. (" + context + ")\n You probably put some other section accidentally in the translation"
2021-04-10 03:50:44 +02:00
}
2020-11-11 16:23:49 +01:00
}
this.translations = translations;
if (count === 0) {
2020-11-11 16:23:49 +01:00
throw `No translations given in the object (${context})`
}
}
get txt(): string {
if (this.translations["*"]) {
return this.translations["*"];
}
const txt = this.translations[Translation.forcedLanguage ?? Locale.language.data];
if (txt !== undefined) {
return txt;
}
const en = this.translations["en"];
if (en !== undefined) {
return en;
}
for (const i in this.translations) {
return this.translations[i]; // Return a random language
}
console.error("Missing language ", Locale.language.data, "for", this.translations)
return "";
}
public SupportedLanguages(): string[] {
const langs = []
for (const translationsKey in this.translations) {
if (translationsKey === "#") {
continue;
}
langs.push(translationsKey)
}
return langs;
}
2020-11-11 16:23:49 +01:00
2020-11-06 01:58:26 +01:00
public Subs(text: any): Translation {
const newTranslations = {};
for (const lang in this.translations) {
let template: string = this.translations[lang];
for (const k in text) {
const combined = [];
const parts = template.split("{" + k + "}");
const el: string | UIElement = text[k];
if (el === undefined) {
continue;
}
let rtext: string = "";
if (typeof (el) === "string") {
rtext = el;
2021-04-11 19:21:41 +02:00
} else if(typeof(el) === "number") {
// HUH? Where did that number come from?
rtext = "" + el;
}else {
2020-11-06 01:58:26 +01:00
Translation.forcedLanguage = lang; // This is a very dirty hack - it'll bite me one day
rtext = el.InnerRender();
2021-04-11 19:21:41 +02:00
2020-11-06 01:58:26 +01:00
}
for (let i = 0; i < parts.length - 1; i++) {
combined.push(parts[i]);
combined.push(rtext)
}
combined.push(parts[parts.length - 1]);
template = new Combine(combined).InnerRender();
}
newTranslations[lang] = template;
}
Translation.forcedLanguage = undefined;
return new Translation(newTranslations);
}
InnerRender(): string {
return this.txt
}
public replace(a: string, b: string) {
if (a.startsWith("{") && a.endsWith("}")) {
a = a.substr(1, a.length - 2);
}
const result = this.Subs({[a]: b});
return result;
}
public Clone() {
return new Translation(this.translations)
}
FirstSentence() {
const tr = {};
for (const lng in this.translations) {
let txt = this.translations[lng];
txt = txt.replace(/\..*/, "");
txt = Utils.EllipsesAfter(txt, 255);
tr[lng] = txt;
}
return new Translation(tr);
}
public ExtractImages(isIcon = false): string[] {
const allIcons: string[] = []
for (const key in this.translations) {
const render = this.translations[key]
if (isIcon) {
const icons = render.split(";").filter(part => part.match(/(\.svg|\.png|\.jpg)$/) != null)
allIcons.push(...icons)
} else if (!Utils.runningFromConsole) {
// This might be a tagrendering containing some img as html
const htmlElement = document.createElement("div")
htmlElement.innerHTML = render
const images = Array.from(htmlElement.getElementsByTagName("img")).map(img => img.src)
allIcons.push(...images)
} else {
// We are running this in ts-node (~= nodejs), and can not access document
// So, we fallback to simple regex
2021-04-10 03:50:44 +02:00
try {
const matches = render.match(/<img[^>]+>/g)
if (matches != null) {
const sources = matches.map(img => img.match(/src=("[^"]+"|'[^']+'|[^/ ]+)/))
.filter(match => match != null)
.map(match => match[1].trim().replace(/^['"]/, '').replace(/['"]$/, ''));
allIcons.push(...sources)
}
2021-04-11 19:21:41 +02:00
} catch (e) {
2021-04-10 03:50:44 +02:00
console.error("Could not search for images: ", render, this.txt)
throw e
}
}
}
return allIcons.filter(icon => icon != undefined)
}
2020-11-06 01:58:26 +01:00
}