Files
Investidor-V2/resources/js/translation/page-translator.tsx
T

194 lines
8.4 KiB
TypeScript

import { useEffect } from 'react';
import { useTempoUi } from '@/components/tempo-brand';
import { TranslationRequestError, translateTexts } from '@/translation/service';
import { protectTranslationTokens, restoreTranslationTokens } from '@/translation/utils';
// Never change the structure of React's DOM or the value of a form control.
const excluded = 'script,style,noscript,code,pre,textarea,[contenteditable]:not([contenteditable="false"]),[translate="no"],[data-no-translate],.no-translate';
const attributes = ['placeholder', 'title', 'aria-label', 'alt'] as const;
type Target = { node: Text | Element; attribute?: string; original: string; translated?: string };
type QueuedText = { value: string; resolve: (value: string) => void; reject: (error: unknown) => void };
const batchMaxItems = 8;
const batchMaxChars = 2200;
const requestMaxChars = 9000;
function read(target: Target): string | null {
return target.attribute ? (target.node as Element).getAttribute(target.attribute) : target.node.nodeValue;
}
function write(target: Target, value: string): void {
if (target.attribute) (target.node as Element).setAttribute(target.attribute, value);
else target.node.nodeValue = value;
}
export function PageTranslator() {
const { language } = useTempoUi();
useEffect(() => {
document.documentElement.lang = language;
if (language === 'pt') return;
let active = true;
const abort = new AbortController();
const targets = new Map<Node, Map<string, Target>>();
const cache = new Map<string, Promise<string>>();
const queue: QueuedText[] = [];
let running = 0;
let timer: ReturnType<typeof setTimeout> | undefined;
let unavailable = false;
let failureReported = false;
const schedule = (delay = 0) => {
if (!active || unavailable || timer || running >= 2 || !queue.length) return;
timer = setTimeout(() => {
timer = undefined;
void flush();
}, delay);
};
const rejectQueued = (error: unknown) => {
if (timer) clearTimeout(timer);
timer = undefined;
queue.splice(0).forEach((item) => item.reject(error));
};
const enqueue = (value: string): Promise<string> =>
new Promise((resolve, reject) => {
queue.push({ value, resolve, reject });
schedule();
});
const flush = async () => {
if (!active || unavailable || running >= 2 || !queue.length) return;
const batch: QueuedText[] = [];
let batchLength = 0;
while (queue.length && batch.length < batchMaxItems) {
const next = queue[0];
if (batch.length > 0 && batchLength + next.value.length > batchMaxChars) break;
batch.push(queue.shift()!);
batchLength += next.value.length;
}
running++;
schedule(650);
try {
const translated = await translateTexts(
batch.map((item) => item.value),
'auto',
language,
abort.signal,
);
batch.forEach((item, index) => item.resolve(translated[index]));
} catch (error) {
const isUnavailable = !abort.signal.aborted
&& error instanceof TranslationRequestError
&& (error.status === 503 || error.status === null);
if (isUnavailable) {
unavailable = true;
rejectQueued(error);
}
batch.forEach((item) => item.reject(error));
} finally {
running--;
schedule(650);
}
};
const splitForRequests = (value: string): string[] => {
const chunks: string[] = [];
let start = 0;
while (start < value.length) {
let end = Math.min(start + requestMaxChars, value.length);
if (end < value.length) {
const boundary = value.lastIndexOf(' ', end);
if (boundary > start) end = boundary + 1;
}
chunks.push(value.slice(start, end));
start = end;
}
return chunks;
};
const translate = (value: string): Promise<string> => {
const previous = cache.get(value);
if (previous) return previous;
const protectedText = protectTranslationTokens(value);
const promise = Promise.all(
splitForRequests(protectedText.text).map(enqueue),
).then((translatedChunks) => {
const translatedText = translatedChunks.join('');
for (const token of protectedText.replacements.keys()) {
if (!translatedText.includes(token)) {
throw new Error('Translation lost a protected token');
}
}
return restoreTranslationTokens(translatedText, protectedText.replacements);
});
cache.set(value, promise);
promise.catch(() => cache.delete(value));
return promise;
};
const consider = (node: Text | Element, attribute?: string) => {
const element = node instanceof Element ? node : node.parentElement;
if (!element || element.closest(excluded)) return;
// Without an explicit value, translating an option changes the submitted value.
if (element.closest('option:not([value])')) return;
const key = attribute ?? '';
const value = attribute ? (node as Element).getAttribute(attribute) : node.nodeValue;
if (!value || !/\p{L}/u.test(value)) return;
let entries = targets.get(node);
if (!entries) { entries = new Map(); targets.set(node, entries); }
const old = entries.get(key);
if (old && (value === old.original || value === old.translated)) return;
const target: Target = { node, attribute, original: value };
entries.set(key, target);
translate(value).then((translated) => {
if (!active || !node.isConnected || entries?.get(key) !== target || read(target) !== value) return;
target.translated = translated;
write(target, translated);
}).catch((error) => {
if (!abort.signal.aborted && !failureReported) {
failureReported = true;
console.error('Page translation failed; original text was kept.', error);
}
});
};
const scan = (root: Node) => {
if (root instanceof Text) { consider(root); return; }
if (!(root instanceof Element)) return;
if (root.closest(excluded)) return;
for (const name of attributes) if (root.hasAttribute(name)) consider(root, name);
const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT);
while (walker.nextNode()) {
const node = walker.currentNode;
if (node instanceof Text) consider(node);
else if (node instanceof Element) for (const name of attributes) if (node.hasAttribute(name)) consider(node, name);
}
};
const observer = new MutationObserver((mutations) => {
for (const mutation of mutations) {
if (mutation.type === 'characterData') scan(mutation.target);
else if (mutation.type === 'attributes' && mutation.target instanceof Element && mutation.attributeName) consider(mutation.target, mutation.attributeName);
else mutation.addedNodes.forEach(scan);
}
});
observer.observe(document.documentElement, { subtree: true, childList: true, characterData: true, attributes: true, attributeFilter: [...attributes] });
scan(document.documentElement);
return () => {
active = false;
abort.abort();
if (timer) clearTimeout(timer);
observer.disconnect();
for (const entries of targets.values()) for (const target of entries.values()) {
if (target.translated !== undefined && read(target) === target.translated) write(target, target.original);
}
};
}, [language]);
return null;
}