[Userscript] Automatically translate Non-English text to English while posting

[Sterlino]

Here, many users may not be proficient in English. They also have to post in English. So, they write in their native language and use Google Translate or another translator. With the help of this userscript, if you paste a non-English language directly, it will be translated into English or if you type directly in your native language, it will be automatically translated into English after the sentence is finished. I apologize if someone has already created a script like this before but I did not find any such script, so I thought it could be shared on the forum.  It may be convenient for users. I used AI as a coding assistant to help with development quickly and debugging.

How it will work.

Chrome's built-in language detector and translator API have been used. As a drawback, it cannot be used in firefox. Because the built-in free translator API as cannot be used directly in firefox. It will support all languages available in Chrome Translator API.

Features

• Pasting and typing  native language text will automatically translate to English.
• Automatic translation will occur when the sentence is finished
• A debounce delay of about 450ms is given after typing. So that processing starts after sentence completion normally so that it doesn't start repeatedly while typing
• No API, no popup, no extra button or interface, simple and minimalistic

Example



Userscript

Code:

// // ==UserScript==
// @name         Bitcointalk Auto English
// @namespace    https://github.com/SterlinoBTT
// @version      1.0.0
// @description  Automatically translates supported non-English text to English while writing  or pasting on Bitcointalk.
// @author       Sterlino
// @match        *://bitcointalk.org/*
// @match        *://www.bitcointalk.org/*
// @run-at       document-idle
// @grant        none
// @inject-into  page
// ==/UserScript==

(function () {
    "use strict";

    const MESSAGE_BOX_SELECTOR = 'textarea[name="message"]';
    const TARGET_LANGUAGE = "en";
    const TYPING_DELAY = 450;
    const SENTENCE_TERMINAL = /\p{Sentence_Terminal}/u;
    const STORAGE_KEY = "bttAutoEnglishLanguages";

    let messageBox = null;
    let detectorPromise = null;
    let typingTimer = null;
    let composing = false;
    let internalChange = false;
    let processing = false;

    const translatorPromises = new Map();
    const jobs = [];

    function hasBuiltInApis() {
        return typeof LanguageDetector !== "undefined" && typeof Translator !== "undefined";
    }

    function readKnownLanguages() {
        try {
            const value = JSON.parse(localStorage.getItem(STORAGE_KEY) || "[]");
            return Array.isArray(value) ? value.filter(Boolean) : [];
        } catch (error) {
            return [];
        }
    }

    function rememberLanguage(language) {
        if (!language || language === TARGET_LANGUAGE) {
            return;
        }

        const languages = new Set(readKnownLanguages());
        languages.add(language);

        try {
            localStorage.setItem(STORAGE_KEY, JSON.stringify(Array.from(languages).slice(-12)));
        } catch (error) {
            // Ignore storage errors.
        }
    }

    function createDetector() {
        if (!hasBuiltInApis()) {
            return Promise.resolve(null);
        }

        if (!detectorPromise) {
            detectorPromise = LanguageDetector.create().catch(function () {
                detectorPromise = null;
                return null;
            });
        }

        return detectorPromise;
    }

    function createTranslator(sourceLanguage) {
        if (!sourceLanguage || sourceLanguage === TARGET_LANGUAGE) {
            return Promise.resolve(null);
        }

        if (!translatorPromises.has(sourceLanguage)) {
            const promise = Translator.create({
                sourceLanguage: sourceLanguage,
                targetLanguage: TARGET_LANGUAGE
            }).then(function (translator) {
                rememberLanguage(sourceLanguage);
                return translator;
            }).catch(function () {
                translatorPromises.delete(sourceLanguage);
                return null;
            });

            translatorPromises.set(sourceLanguage, promise);
        }

        return translatorPromises.get(sourceLanguage);
    }

    function warmUpFromUserAction() {
        createDetector();

        const languages = new Set(readKnownLanguages());

        for (const job of jobs) {
            if (job.sourceLanguage && job.sourceLanguage !== TARGET_LANGUAGE) {
                languages.add(job.sourceLanguage);
            }
        }

        for (const language of languages) {
            createTranslator(language).then(function () {
                processJobs();
            });
        }
    }

    async function detectSourceLanguage(text) {
        const detector = await createDetector();

        if (!detector) {
            return null;
        }

        let results;

        try {
            results = await detector.detect(text);
        } catch (error) {
            return null;
        }

        if (!Array.isArray(results) || results.length === 0) {
            return null;
        }

        const top = results[0];

        if (top && top.detectedLanguage === TARGET_LANGUAGE && top.confidence >= 0.5) {
            return TARGET_LANGUAGE;
        }

        const candidates = results
            .filter(function (item) {
                return item && item.detectedLanguage && item.detectedLanguage !== "und";
            })
            .slice(0, 8);

        for (const candidate of candidates) {
            const code = candidate.detectedLanguage;

            if (code === TARGET_LANGUAGE) {
                continue;
            }

            try {
                const status = await Translator.availability({
                    sourceLanguage: code,
                    targetLanguage: TARGET_LANGUAGE
                });

                if (status !== "unavailable") {
                    return code;
                }
            } catch (error) {
                continue;
            }
        }

        if (top && top.detectedLanguage === TARGET_LANGUAGE) {
            return TARGET_LANGUAGE;
        }

        return null;
    }

    function findClosestText(value, text, preferredStart) {
        if (value.slice(preferredStart, preferredStart + text.length) === text) {
            return preferredStart;
        }

        let bestPosition = -1;
        let bestDistance = Infinity;
        let position = value.indexOf(text);

        while (position !== -1) {
            const distance = Math.abs(position - preferredStart);

            if (distance < bestDistance) {
                bestPosition = position;
                bestDistance = distance;
            }

            position = value.indexOf(text, position + 1);
        }

        return bestPosition;
    }

    function adjustPosition(position, start, oldLength, newLength) {
        const end = start + oldLength;
        const delta = newLength - oldLength;

        if (position <= start) {
            return position;
        }

        if (position >= end) {
            return position + delta;
        }

        return start + newLength;
    }

    function replaceJobText(job, translatedText) {
        if (!messageBox || !document.contains(messageBox)) {
            return false;
        }

        const currentValue = messageBox.value;
        const start = findClosestText(currentValue, job.text, job.start);

        if (start < 0) {
            return false;
        }

        const end = start + job.text.length;
        const selectionStart = messageBox.selectionStart;
        const selectionEnd = messageBox.selectionEnd;
        const replacement = translatedText;
        const delta = replacement.length - job.text.length;

        internalChange = true;

        messageBox.value =
            currentValue.slice(0, start) +
            replacement +
            currentValue.slice(end);

        const newSelectionStart = adjustPosition(
            selectionStart,
            start,
            job.text.length,
            replacement.length
        );

        const newSelectionEnd = adjustPosition(
            selectionEnd,
            start,
            job.text.length,
            replacement.length
        );

        messageBox.setSelectionRange(newSelectionStart, newSelectionEnd);
        messageBox.dispatchEvent(new Event("input", { bubbles: true }));

        internalChange = false;

        for (const queuedJob of jobs) {
            if (queuedJob !== job && queuedJob.start > start) {
                queuedJob.start += delta;
            }
        }

        return true;
    }

    function prepareJobLanguage(job) {
        if (job.sourceLanguage) {
            return Promise.resolve(job.sourceLanguage);
        }

        if (!job.languagePromise) {
            job.languagePromise = detectSourceLanguage(job.text).then(function (language) {
                job.sourceLanguage = language;
                job.languagePromise = null;
                return language;
            });
        }

        return job.languagePromise;
    }

    function preparePendingJobs() {
        const pending = jobs.filter(function (job) {
            return !job.sourceLanguage;
        });

        if (pending.length === 0) {
            processJobs();
            return;
        }

        Promise.all(pending.map(prepareJobLanguage)).then(function () {
            processJobs();
        });
    }

    async function processJobs() {
        if (processing || jobs.length === 0 || !hasBuiltInApis()) {
            return;
        }

        processing = true;

        try {
            while (jobs.length > 0) {
                const job = jobs[0];

                if (!job.sourceLanguage) {
                    job.sourceLanguage = await prepareJobLanguage(job);
                }

                if (!job.sourceLanguage) {
                    jobs.shift();
                    continue;
                }

                if (job.sourceLanguage === TARGET_LANGUAGE) {
                    jobs.shift();
                    continue;
                }

                const translator = await createTranslator(job.sourceLanguage);

                if (!translator) {
                    break;
                }

                let translatedText;

                try {
                    translatedText = await translator.translate(job.text);
                } catch (error) {
                    jobs.shift();
                    continue;
                }

                if (typeof translatedText === "string" && translatedText.trim()) {
                    replaceJobText(job, translatedText);
                }

                jobs.shift();
            }
        } finally {
            processing = false;
        }
    }

    function isDuplicateJob(text, start) {
        return jobs.some(function (job) {
            return job.start === start && job.text === text;
        });
    }

    function addJob(text, start) {
        if (!text || !text.trim() || isDuplicateJob(text, start)) {
            return;
        }

        jobs.push({
            text: text,
            start: start,
            sourceLanguage: null,
            languagePromise: null
        });
    }

    function addTrimmedJob(text, baseStart) {
        const leading = text.match(/^\s*/)[0].length;
        const trailing = text.match(/\s*$/)[0].length;
        const end = text.length - trailing;

        if (end <= leading) {
            return;
        }

        addJob(text.slice(leading, end), baseStart + leading);
    }

    function addPastedJobs(text, baseStart) {
        let segmentStart = 0;

        for (let index = 0; index < text.length; index += 1) {
            const character = text.charAt(index);

            if (SENTENCE_TERMINAL.test(character)) {
                addTrimmedJob(text.slice(segmentStart, index + 1), baseStart + segmentStart);
                segmentStart = index + 1;
                continue;
            }

            if (character === "\n") {
                addTrimmedJob(text.slice(segmentStart, index), baseStart + segmentStart);
                segmentStart = index + 1;
            }
        }

        if (segmentStart < text.length) {
            addTrimmedJob(text.slice(segmentStart), baseStart + segmentStart);
        }

        preparePendingJobs();
    }

    function insertPastedText(event) {
        if (!messageBox || composing) {
            return;
        }

        const clipboard = event.clipboardData;

        if (!clipboard) {
            return;
        }

        const pastedText = clipboard.getData("text/plain");

        if (!pastedText) {
            return;
        }

        event.preventDefault();
        warmUpFromUserAction();

        const start = messageBox.selectionStart;
        const end = messageBox.selectionEnd;
        const before = messageBox.value.slice(0, start);
        const after = messageBox.value.slice(end);
        const caret = start + pastedText.length;

        internalChange = true;
        messageBox.value = before + pastedText + after;
        messageBox.setSelectionRange(caret, caret);
        messageBox.dispatchEvent(new Event("input", { bubbles: true }));
        internalChange = false;

        addPastedJobs(pastedText, start);
    }

    function findCompletedSentence() {
        if (!messageBox) {
            return null;
        }

        const caret = messageBox.selectionStart;

        if (caret <= 0 || messageBox.selectionStart !== messageBox.selectionEnd) {
            return null;
        }

        const value = messageBox.value;
        let end = caret;
        let terminalIndex = end - 1;

        while (terminalIndex >= 0 && /\s/.test(value.charAt(terminalIndex))) {
            terminalIndex -= 1;
        }

        if (terminalIndex < 0) {
            return null;
        }

        const terminalCharacter = value.charAt(terminalIndex);

        if (!SENTENCE_TERMINAL.test(terminalCharacter)) {
            return null;
        }

        let start = terminalIndex;

        while (start > 0) {
            const previousCharacter = value.charAt(start - 1);

            if (previousCharacter === "\n" || SENTENCE_TERMINAL.test(previousCharacter)) {
                break;
            }

            start -= 1;
        }

        while (start < terminalIndex && /[ \t\r\n]/.test(value.charAt(start))) {
            start += 1;
        }

        end = terminalIndex + 1;

        const text = value.slice(start, end);

        if (!text.trim()) {
            return null;
        }

        return { text: text, start: start };
    }

    function scheduleTypedSentence() {
        clearTimeout(typingTimer);

        typingTimer = setTimeout(function () {
            if (composing || internalChange) {
                return;
            }

            const sentence = findCompletedSentence();

            if (sentence) {
                addJob(sentence.text, sentence.start);
                preparePendingJobs();
            }
        }, TYPING_DELAY);
    }

    function attachToMessageBox(box) {
        if (!box || box.dataset.autoEnglishAttached === "1") {
            return;
        }

        messageBox = box;
        messageBox.dataset.autoEnglishAttached = "1";

        messageBox.addEventListener("keydown", warmUpFromUserAction);
        messageBox.addEventListener("mousedown", warmUpFromUserAction);
        messageBox.addEventListener("paste", insertPastedText);

        messageBox.addEventListener("compositionstart", function () {
            composing = true;
            clearTimeout(typingTimer);
        });

        messageBox.addEventListener("compositionend", function () {
            composing = false;
            scheduleTypedSentence();
        });

        messageBox.addEventListener("input", function () {
            if (!internalChange && !composing) {
                scheduleTypedSentence();
            }
        });
    }

    function initialize() {
        const box = document.querySelector(MESSAGE_BOX_SELECTOR);

        if (box) {
            attachToMessageBox(box);
            return true;
        }

        return false;
    }

    if (!initialize()) {
        const observer = new MutationObserver(function () {
            if (initialize()) {
                observer.disconnect();
            }
        });

        observer.observe(document.documentElement, {
            childList: true,
            subtree: true
        });
    }
})();

GitHub Source

https://github.com/SterlinoBTT

Installation

• Install Tampermonkey.
• Select Create a new script.
• Paste the above userscript code and save it.
• The script also works with Violentmonkey.

[Findingnemo]

I believe this tool will lead to a lot of posts will be flagged as AI. Google Translate uses LLMs too and when we use any AI detector, the results will be more of positrive for AI content, so it is better not to use translator tools to post.

One need to be okay with their english if they want to interact in the main board, doesn't need to be perfect it has to be okaish and if they can't even manage that then it is better for them to stay away from main board.

[Upgrade00]

I believe this tool will lead to a lot of posts will be flagged as AI. Google Translate uses LLMs too and when we use any AI detector, the results will be more of positrive for AI content, so it is better not to use translator tools to post.

Anyone who uses something like this should include in the post that it was translated with AI.

One need to be okay with their english if they want to interact in the main board, doesn't need to be perfect it has to be okaish and if they can't even manage that then it is better for them to stay away from main board.

I agree with this but a member could have a request they want an answer to, that no one is technical enough in their local board to provide. Some others may not have a local board here at all.

[Findingnemo]

One need to be okay with their english if they want to interact in the main board, doesn't need to be perfect it has to be okaish and if they can't even manage that then it is better for them to stay away from main board.

I agree with this but a member could have a request they want an answer to, that no one is technical enough in their local board to provide. Some others may not have a local board here at all.

Valid reason to post beyond their local board but in that case they don't need to post it as the original contents because it is not their original writing, they can always use quote tags and paste the translated content inside them which mitigates the post being considered AI and any other things related to it.

[Upgrade00]

Translated posts are still the content of the original writer. If someone translates a post into a different language they will still have to quote the author.
It's only not your content if you asked AI to write a text for you on that topic or you copied it.

[The Cryptovator]

I won’t welcome these tools; this script is really unnecessary when there are a lot of AIs to do this job. But it will be detected as AI content, as other users have already said. So using your script means users posting through AI directly. Using the AI agent and using your script is same.

Most probably users will get banned if they use those tools constantly. It means, besides being unnecessary, that tools will be risky to use for the forum users at least. This isn’t a great job when Google translations have existed for a long time. Users simply could use Google Translate and copy-paste, but that will be AI content. Same for your tools as well.

Also, if you want to reply in the English section, then you have to understand English as well; using a translator for reading posts would lead to misunderstandings or misinformation. Then your reply won't be relevant to the topic and would be considered spam as well. So at least I am not going to use those tools.

[Alvin_talk]

I apologize if someone has already created a script like this before but I did not find any such script, so I thought it could be shared on the forum.

Similar tool available already. I found this in the 6th page of Meta.
[1] https://bitcointalk.org/index.php?topic=5583973.0

Personally, I do not fancy translation tools, as it tends to mix up context at times. It also lack cultural nuance thereby leading to mistranslation at times too. It is better to learn and improve in your English before posting in the English boards, avoid shortcuts.

If you feel your topic needs to reach the English boards, it is better you politely ask an experienced user in your local board who is fluent in English to help you out with the translation. This way you will save yourself of any unnecessary drama that comes with using ai for your translation.

[Sterlino]

I believe this tool will lead to a lot of posts will be flagged as AI. Google Translate uses LLMs too and when we use any AI detector, the results will be more of positrive for AI content, so it is better not to use translator tools to post.

One need to be okay with their english if they want to interact in the main board, doesn't need to be perfect it has to be okaish and if they can't even manage that then it is better for them to stay away from main board.

You have raised a logical point. Even then, those who are less proficient in English language may depend on Google Translate. it seems that Google Translate has added Gemini based translation. So, if you translate there, there may be AI related problems, but this script uses Chrome' Translator API, so there may be less chance of AI tone creation here.   

Google Translate also keep an option that allows you to use the classic version instead of the AI-powered translation if you wish.

I apologize if someone has already created a script like this before but I did not find any such script, so I thought it could be shared on the forum.

Similar tool available already. I found this in the 6th page of Meta.
[1] https://bitcointalk.org/index.php?topic=5583973.0

I saw this when I searched to see if there was any userscript like this before . Here only the post translation feature is given.
And the one I shared, when you write a realtime post in your native language in the reply box, when a sentence ends, it will automatically be translated into English.

[DYING_S0UL]

No offence OP, but using this particular tools is like "Digging your own grave", or at least i think it that way.

In the early days, when AI wasn't this rampant, maybe then something like this would have been acceptable. But right now, when everyone is into AI, and everything is deeply integrated with AI (or in the process of it). And assuming you know forum is really strict with the use of AI for posting. So for the sake of that, and in order to keep ourselves from getting banned, we need to keep ourselves away from such automated tools.

Yeah, if you are confused, then use AI or google translator or other tool to explain it to you. But nothing more than that.

If one cannot read write English, then they should learn it instead. If they can write (even with broken English), and make others understand their opinion. Then that's more than ok. Nobody wants/expects perfect English, nor anybody would complain against one another for having grammer faults.