@lizardbyte/shared-web 2026.314.32913 → 2026.811.210538

package/tests/crowdin.test.js

@@ -17,6 +17,37 @@ jest.mock('../src/js/load-script', () => {
 
 const initCrowdIn = require('../src/js/crowdin');
 
+const delayedPickerMarkup = `
+    <div id="crowdin-language-picker" class="cr-position-bottom-left">
+        <div class="cr-picker-button"></div>
+        <div class="cr-picker-submenu"></div>
+    </div>
+`;
+
+function expectDelayedStyling(options) {
+    globalThis.document.body.innerHTML = options.initialMarkup;
+
+    initCrowdIn('LizardByte', options.platform);
+
+    expect(() => {
+        jest.advanceTimersByTime(0);
+    }).not.toThrow();
+
+    globalThis.document.body.insertAdjacentHTML('beforeend', delayedPickerMarkup);
+
+    jest.advanceTimersByTime(50);
+
+    const container = document.getElementById('crowdin-language-picker');
+    const sidebar = document.getElementsByClassName(options.sidebarClass)[0];
+
+    expect(container.classList.contains('cr-position-bottom-left')).toBe(false);
+    expect(container.style.position).toBe(options.position);
+    if (options.pickerClass !== null) {
+        expect(container.classList.contains(options.pickerClass)).toBe(true);
+    }
+    expect(sidebar.contains(container)).toBe(true);
+}
+
 describe('initCrowdIn', () => {
     beforeEach(() => {
         // Mock DOM elements
@@ -29,6 +60,11 @@ describe('initCrowdIn', () => {
 
             <!-- Sphinx sidebar -->
             <div class="sidebar-sticky"></div>
+
+            <!-- rustdoc sidebar -->
+            <nav class="sidebar">
+                <div class="sidebar-elems"></div>
+            </nav>
         `;
 
         // Mock console.error
@@ -50,6 +86,7 @@ describe('initCrowdIn', () => {
         jest.clearAllMocks();
         jest.useRealTimers();
         delete globalThis.window.proxyTranslator;
+        delete globalThis.window.i18nextify;
         delete globalThis._crowdinMirrorInstalled;
     });
 
@@ -60,7 +97,7 @@ describe('initCrowdIn', () => {
 
     it('should validate platform parameter', () => {
         initCrowdIn('LizardByte', 'invalidPlatform');
-        expect(console.error).toHaveBeenCalledWith('Invalid UI. Must be "sphinx", or null');
+        expect(console.error).toHaveBeenCalledWith('Invalid UI. Must be "sphinx", "rustdoc", or null');
     });
 
     it('should initialize proxyTranslator with LizardByte settings', () => {
@@ -78,6 +115,89 @@ describe('initCrowdIn', () => {
         );
     });
 
+    it('should only pass supported Website Translator options', () => {
+        initCrowdIn();
+
+        // Simulate script loading
+        jest.runAllTimers();
+
+        const options = globalThis.proxyTranslator.init.mock.calls[0][0];
+        expect(Object.keys(options).sort()).toEqual([
+            'baseUrl',
+            'callback',
+            'defaultLanguage',
+            'distribution',
+            'languageRoutingMethod',
+            'languageTitles',
+            'position',
+            'poweredBy',
+            'showDefaultLanguageInUrl',
+            'submenuPosition',
+        ]);
+    });
+
+    it('should restore whitespace around translated inline elements', () => {
+        globalThis.document.body.innerHTML = `
+            <p id="translated">
+                GitHub <em>Discussions</em> are available. <strong>Yearly:</strong> <strong>$14.99</strong>, billed.
+            </p>
+            <p id="detached">Before <i>removed</i></p>
+            <p id="next-anchor"><i>gone</i> <strong>kept</strong></p>
+            <p id="no-anchor"><i>gone</i> <strong>also gone</strong></p>
+        `;
+
+        initCrowdIn();
+        jest.runAllTimers();
+
+        const options = globalThis.proxyTranslator.init.mock.calls[0][0];
+        const translated = globalThis.document.getElementById('translated');
+        const emphasis = translated.querySelector('em');
+        const strongElements = translated.querySelectorAll('strong');
+        const detachedBoundary = globalThis.document.querySelector('#detached i').previousSibling;
+        const nextAnchor = globalThis.document.getElementById('next-anchor');
+        const nextAnchorWhitespace = nextAnchor.querySelector('i').nextSibling;
+        const noAnchor = globalThis.document.getElementById('no-anchor');
+
+        emphasis.previousSibling.replaceWith(document.createTextNode('GitHub'));
+        emphasis.nextSibling.replaceWith(document.createTextNode('are available. '));
+        strongElements[0].nextSibling.remove();
+        detachedBoundary.remove();
+        nextAnchor.querySelector('i').remove();
+        nextAnchorWhitespace.remove();
+        noAnchor.remove();
+
+        options.callback();
+        options.callback();
+
+        expect(translated.textContent.trim()).toBe(
+            'GitHub Discussions are available. Yearly: $14.99, billed.'
+        );
+        expect(nextAnchor.textContent).toBe(' kept');
+    });
+
+    it('should restore whitespace after later asynchronous DOM changes', async () => {
+        globalThis.document.body.innerHTML = '<p id="translated">Use <a href="#">this link</a> here.</p>';
+
+        initCrowdIn();
+        jest.runAllTimers();
+
+        const options = globalThis.proxyTranslator.init.mock.calls[0][0];
+        const translated = globalThis.document.getElementById('translated');
+        const link = translated.querySelector('a');
+
+        options.callback();
+        link.previousSibling.data = link.previousSibling.data.trimEnd();
+        await Promise.resolve();
+
+        expect(translated.textContent).toBe('Use this link here.');
+
+        jest.advanceTimersByTime(1000);
+        link.nextSibling.data = link.nextSibling.data.trimStart();
+        await Promise.resolve();
+
+        expect(translated.textContent).toBe('Use this link here.');
+    });
+
     it('should initialize proxyTranslator with LizardByte-docs settings', () => {
         initCrowdIn('LizardByte-docs');
 
@@ -117,11 +237,80 @@ describe('initCrowdIn', () => {
         expect(container.style.position).toBe('relative');
         expect(sidebar.contains(container)).toBe(true);
     });
+
+    it('should apply rustdoc styling', () => {
+        initCrowdIn('LizardByte', 'rustdoc');
+
+        // Simulate script loading and UI styling timeout
+        jest.runAllTimers();
+
+        const container = document.getElementById('crowdin-language-picker');
+        const sidebar = document.getElementsByClassName('sidebar-elems')[0];
+
+        expect(container.classList.contains('cr-position-bottom-left')).toBe(false);
+        expect(container.classList.contains('rustdoc-crowdin-picker')).toBe(true);
+        expect(container.style.position).toBe('static');
+        expect(sidebar.contains(container)).toBe(true);
+    });
+
+    it('should wait for sphinx language picker before applying styling', () => {
+        expectDelayedStyling({
+            initialMarkup: '<div class="sidebar-sticky"></div>',
+            pickerClass: null,
+            platform: 'sphinx',
+            position: 'relative',
+            sidebarClass: 'sidebar-sticky',
+        });
+    });
+
+    it('should wait for rustdoc language picker before applying styling', () => {
+        expectDelayedStyling({
+            initialMarkup: '<nav class="sidebar"><div class="sidebar-elems"></div></nav>',
+            pickerClass: 'rustdoc-crowdin-picker',
+            platform: 'rustdoc',
+            position: 'static',
+            sidebarClass: 'sidebar-elems',
+        });
+    });
+
+    it('should move rustdoc language picker to sidebar when sidebar-elems is unavailable', () => {
+        globalThis.document.body.innerHTML = `
+            <nav class="sidebar"></nav>
+            <div id="crowdin-language-picker" class="cr-position-bottom-left">
+                <div class="cr-picker-button"></div>
+                <div class="cr-picker-submenu"></div>
+            </div>
+        `;
+
+        initCrowdIn('LizardByte', 'rustdoc');
+        jest.runAllTimers();
+
+        const container = document.getElementById('crowdin-language-picker');
+        const sidebar = document.getElementsByClassName('sidebar')[0];
+
+        expect(container.classList.contains('rustdoc-crowdin-picker')).toBe(true);
+        expect(sidebar.contains(container)).toBe(true);
+    });
+
+    it('should stop retrying platform styling after the retry limit', () => {
+        globalThis.document.body.innerHTML = `
+            <nav class="sidebar">
+                <div class="sidebar-elems"></div>
+            </nav>
+        `;
+
+        initCrowdIn('LizardByte', 'rustdoc');
+
+        jest.advanceTimersByTime(0);
+        jest.advanceTimersByTime(5000);
+
+        expect(jest.getTimerCount()).toBe(0);
+    });
 });
 
 describe('Crowdin fetch interceptor', () => {
     const CROWDIN_CDN = 'https://distributions.crowdin.net';
-    const MIRROR = 'https://cdn.jsdelivr.net/gh/LizardByte/shared-web@crowdin-dist';
+    const MIRROR = 'https://cdn.jsdelivr.net/gh/LizardByte/i18n@dist';
 
     beforeEach(() => {
         // Reset interceptor state so each test gets a fresh install
@@ -214,4 +403,39 @@ describe('Crowdin fetch interceptor', () => {
 
         expect(globalThis.fetch).toBe(fetchAfterFirst);
     });
+
+    it('should continue when fetch is unavailable', () => {
+        delete globalThis.fetch;
+
+        initCrowdIn();
+        jest.runAllTimers();
+
+        expect(globalThis.proxyTranslator.init).toHaveBeenCalled();
+    });
+
+    it('should pass non-string fetch inputs through unchanged', async () => {
+        const mockFetch = globalThis.fetch;
+        const requestLike = new URL('https://example.com/data.json');
+
+        initCrowdIn();
+        jest.runAllTimers();
+
+        await globalThis.fetch(requestLike);
+
+        const calledUrl = mockFetch.mock.calls[0][0];
+        expect(calledUrl).toBe(requestLike);
+    });
+
+    it('should pass invalid URL strings through unchanged', async () => {
+        const mockFetch = globalThis.fetch;
+        const invalidUrl = 'not a valid absolute URL';
+
+        initCrowdIn();
+        jest.runAllTimers();
+
+        await globalThis.fetch(invalidUrl);
+
+        const calledUrl = mockFetch.mock.calls[0][0];
+        expect(calledUrl).toBe(invalidUrl);
+    });
 });

package/tests/global-exposure.test.js

@@ -0,0 +1,31 @@
+/**
+ * @jest-environment node
+ */
+
+import {
+    describe,
+    expect,
+    it,
+    jest,
+} from '@jest/globals';
+
+const exposedModules = [
+    ['formatNumber', '../src/js/format-number'],
+    ['initCrowdIn', '../src/js/crowdin'],
+    ['levenshteinDistance', '../src/js/levenshtein-distance'],
+    ['loadScript', '../src/js/load-script'],
+    ['rankingSorter', '../src/js/ranking-sorter'],
+    ['sleep', '../src/js/sleep'],
+];
+
+describe('global browser exposure', () => {
+    it.each(exposedModules)('should not expose %s when window is unavailable', (globalName, modulePath) => {
+        jest.resetModules();
+
+        const moduleExport = require(modulePath);
+
+        expect(globalThis.window).toBeUndefined();
+        expect(moduleExport).toBeDefined();
+        expect(globalThis[globalName]).toBeUndefined();
+    });
+});

package/tests/load-script.test.js

@@ -45,4 +45,26 @@ describe('loadScript', () => {
     expect(script).toBeInstanceOf(HTMLScriptElement);
     expect(script.src).toBe(url);
   });
+
+  it('should handle load without a callback', () => {
+    const url = 'https://example.com/test-script.js';
+    loadScript(url);
+
+    const script = document.head.querySelector('script');
+
+    expect(() => {
+      script.onload();
+    }).not.toThrow();
+  });
+
+  it('should handle failure without a callback', () => {
+    const url = 'https://example.com/test-script.js';
+    loadScript(url);
+
+    const script = document.head.querySelector('script');
+
+    expect(() => {
+      script.onerror();
+    }).not.toThrow();
+  });
 });

package/tests/sleep.test.js

@@ -26,7 +26,7 @@ describe('sleep function', () => {
         [2000], // 2 seconds
         [60000], // 60 seconds
     ])('resolves after %i milliseconds', async (delay) => {
-        let delay_value = delay[0];
+        const delay_value = delay;
         const sleepPromise = sleep(delay_value);
         jest.advanceTimersByTime(delay_value);
         await sleepPromise;