@lizardbyte/shared-web 2024.901.15440

package/src/js/levenshtein-distance.js

@@ -0,0 +1,36 @@
+function levenshteinDistance(a, b) {
+    if (a.length === 0) return b.length;
+    if (b.length === 0) return a.length;
+
+    let matrix = [];
+
+    // increment along the first column of each row
+    let i;
+    for (i = 0; i <= b.length; i++) {
+        matrix[i] = [i];
+    }
+
+    // increment each column in the first row
+    let j;
+    for (j = 0; j <= a.length; j++) {
+        matrix[0][j] = j;
+    }
+
+    // Fill in the rest of the matrix
+    for (i = 1; i <= b.length; i++) {
+        for (j = 1; j <= a.length; j++) {
+            if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                matrix[i][j] = matrix[i - 1][j - 1];
+            } else {
+                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, // substitution
+                    Math.min(matrix[i][j - 1] + 1, // insertion
+                        matrix[i - 1][j] + 1)); // deletion
+            }
+        }
+    }
+
+    // return the percentage of the levenshtein distance
+    return (1 - (matrix[b.length][a.length] / Math.max(a.length, b.length))) * 100
+}
+
+module.exports = levenshteinDistance;

package/src/js/lizardbyte-css.js

@@ -0,0 +1 @@
+import "../css/lizardbyte.scss";

package/src/js/load-script.js

@@ -0,0 +1,22 @@
+/**
+ * Load a script asynchronously, and add it to the DOM. Optionally, call a callback when the script has loaded.
+ * @param url The URL of the script to load.
+ * @param callback An optional callback to call when the script has loaded.
+ */
+function loadScript(url, callback) {
+    const script = document.createElement('script');
+    script.src = url;
+    script.async = true;
+
+    script.onload = () => {
+        if (callback) callback(null, script);
+    };
+
+    script.onerror = () => {
+        if (callback) callback(new Error(`Failed to load script: ${url}`));
+    };
+
+    document.head.appendChild(script);
+}
+
+module.exports = loadScript;

package/src/js/random-quote.js

@@ -0,0 +1,25 @@
+let quoteCache = null;
+
+/**
+ * Fetch a random quote from our API.
+ * @returns {Promise<*>} A promise that resolves with a random quote
+ */
+async function fetchRandomQuote() {
+    if (!quoteCache) {
+        const response = await fetch('https://app.lizardbyte.dev/uno/random-quotes/games.json');
+        quoteCache = await response.json();
+    }
+    return quoteCache[Math.floor(Math.random() * quoteCache.length)];
+}
+
+/**
+ * Reset the quote cache.
+ */
+function resetQuoteCache() {
+    quoteCache = null;
+}
+
+module.exports = {
+    fetchRandomQuote,
+    resetQuoteCache,
+};

package/src/js/ranking-sorter.js

@@ -0,0 +1,26 @@
+/**
+ * Sorts an array of objects by two keys in descending order.
+ * @param firstKey The primary key to sort by.
+ * @param secondKey The secondary key to sort by, in case the first key is equal.
+ * @returns {(function(*, *): (number))|*} The sorting function.
+ */
+let rankingSorter = function (firstKey, secondKey) {
+    return function(a, b) {
+        if (a[firstKey] > b[firstKey]) {
+            return -1;
+        } else if (a[firstKey] < b[firstKey]) {
+            return 1;
+        }
+        else {
+            if (a[secondKey] > b[secondKey]) {
+                return 1;
+            } else if (a[secondKey] < b[secondKey]) {
+                return -1;
+            } else {
+                return 0;
+            }
+        }
+    }
+}
+
+module.exports = rankingSorter;

package/src/js/sleep.js

@@ -0,0 +1,10 @@
+/**
+ * Sleep for a given amount of time.
+ * @param ms The time to sleep in milliseconds
+ * @returns {Promise<unknown>} A promise that resolves after the given time
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+module.exports = sleep;

package/tests/levenshtein-distance.test.js

@@ -0,0 +1,26 @@
+import {
+    describe,
+    expect,
+    test,
+} from '@jest/globals';
+
+const levenshteinDistance = require('../src/js/levenshtein-distance');
+
+describe('levenshteinDistance', () => {
+  const testCases = [
+    { a: 'test', b: 'test', expected: 100 },
+    { a: 'abc', b: 'xyz', expected: 0 },
+    { a: 'kitten', b: 'sitting', expected: 57.14 },
+    { a: 'flaw', b: 'lawn', expected: 50 },
+    { a: '', b: 'nonempty', expected: 8 },
+    { a: 'nonempty', b: '', expected: 8 }
+  ];
+
+  test.each(testCases)(
+    'should return $expected when comparing "$a" and "$b"',
+    ({ a, b, expected }) => {
+      const result = levenshteinDistance(a, b);
+      expect(result).toBeCloseTo(expected, 2);
+    }
+  );
+});

package/tests/load-script.test.js

@@ -0,0 +1,48 @@
+import {
+    beforeEach,
+    describe,
+    expect,
+    it,
+} from '@jest/globals';
+
+const loadScript = require('../src/js/load-script');
+
+describe('loadScript', () => {
+  beforeEach(() => {
+    document.head.innerHTML = '';
+  });
+
+  it('should load a script and call the callback on success', (done) => {
+    const url = 'https://example.com/test-script.js';
+    loadScript(url, (err, script) => {
+      expect(err).toBeNull();
+      expect(script).toBeInstanceOf(HTMLScriptElement);
+      expect(script.src).toBe(url);
+      done();
+    });
+
+    const script = document.head.querySelector('script');
+    script.onload();
+  });
+
+  it('should call the callback with an error on failure', (done) => {
+    const url = 'https://example.com/test-script.js';
+    loadScript(url, (err) => {
+      expect(err).toBeInstanceOf(Error);
+      expect(err.message).toBe(`Failed to load script: ${url}`);
+      done();
+    });
+
+    const script = document.head.querySelector('script');
+    script.onerror();
+  });
+
+  it('should load a script without a callback', () => {
+    const url = 'https://example.com/test-script.js';
+    loadScript(url);
+
+    const script = document.head.querySelector('script');
+    expect(script).toBeInstanceOf(HTMLScriptElement);
+    expect(script.src).toBe(url);
+  });
+});

package/tests/random-quote.test.js

@@ -0,0 +1,77 @@
+import {
+    afterEach,
+    beforeEach,
+    describe,
+    expect,
+    it,
+    jest,
+} from '@jest/globals';
+
+const { fetchRandomQuote, resetQuoteCache } = require('../src/js/random-quote');
+
+describe('fetchRandomQuote', () => {
+    let originalFetch;
+
+    beforeEach(() => {
+        // Save the original fetch function
+        originalFetch = globalThis.fetch;
+        // Clear the quote cache before each test
+        jest.resetModules();
+        // Reset the quotesCache
+        resetQuoteCache();
+    });
+
+    afterEach(() => {
+        // Restore the original fetch function
+        globalThis.fetch = originalFetch;
+    });
+
+    it('should fetch and return a random quote', async () => {
+        const mockQuotes = [
+            { quote: 'Quote 1' },
+            { quote: 'Quote 2' },
+            { quote: 'Quote 3' }
+        ];
+
+        globalThis.fetch = jest.fn(() =>
+            Promise.resolve({
+                json: () => Promise.resolve(mockQuotes)
+            })
+        );
+
+        const quote = await fetchRandomQuote();
+        expect(mockQuotes).toContainEqual(quote);
+        expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+    });
+
+    it('should return a cached quote if already fetched', async () => {
+        const mockQuotes = [
+            { quote: 'Quote 1' },
+            { quote: 'Quote 2' },
+            { quote: 'Quote 3' }
+        ];
+
+        globalThis.fetch = jest.fn(() =>
+            Promise.resolve({
+                json: () => Promise.resolve(mockQuotes)
+            })
+        );
+
+        // First call to populate the cache
+        await fetchRandomQuote();
+        // Second call should use the cache
+        const quote = await fetchRandomQuote();
+
+        expect(mockQuotes).toContainEqual(quote);
+        expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle fetch errors gracefully', async () => {
+        globalThis.fetch = jest.fn(() =>
+            Promise.reject(new Error('Failed to fetch'))
+        );
+
+        await expect(fetchRandomQuote()).rejects.toThrow('Failed to fetch');
+        expect(globalThis.fetch).toHaveBeenCalledTimes(1);
+    });
+});

package/tests/ranking-sorter.test.js

@@ -0,0 +1,55 @@
+import {
+    describe,
+    expect,
+    it,
+} from '@jest/globals';
+
+const rankingSorter = require('../src/js/ranking-sorter');
+
+describe('rankingSorter', () => {
+  const testCases = [
+    {
+      description: 'should sort by firstKey descending and secondKey ascending',
+      data: [
+        { key1: 1, key2: 2 },
+        { key1: 2, key2: 1 },
+        { key1: 1, key2: 1 }
+      ],
+      expected: [
+        { key1: 2, key2: 1 },
+        { key1: 1, key2: 1 },
+        { key1: 1, key2: 2 }
+      ]
+    },
+    {
+      description: 'should return 1 when firstKey values are equal and secondKey of first object is greater',
+      data: [
+        { key1: 1, key2: 2 },
+        { key1: 1, key2: 1 }
+      ],
+      expected: 1,
+      compare: true
+    },
+    {
+      description: 'should return 0 when both firstKey and secondKey values are equal',
+      data: [
+        { key1: 1, key2: 1 },
+        { key1: 1, key2: 1 }
+      ],
+      expected: 0,
+      compare: true
+    }
+  ];
+
+  testCases.forEach(({ description, data, expected, compare }) => {
+    it(description, () => {
+      if (compare) {
+        const result = rankingSorter('key1', 'key2')(data[0], data[1]);
+        expect(result).toBe(expected);
+      } else {
+        const sorted = data.sort(rankingSorter('key1', 'key2'));
+        expect(sorted).toEqual(expected);
+      }
+    });
+  });
+});

package/tests/sleep.test.js

@@ -0,0 +1,41 @@
+import {
+    afterAll,
+    beforeAll,
+    beforeEach,
+    describe,
+    expect,
+    jest,
+    test,
+} from '@jest/globals';
+
+const sleep = require('../src/js/sleep');
+
+describe('sleep function', () => {
+    beforeAll(() => {
+        jest.useFakeTimers();
+    })
+
+    beforeEach(() => {
+        jest.spyOn(global, 'setTimeout');
+    });
+
+    test.each([
+        [500],  // 0.5 second
+        [1000], // 1 second
+        [1500], // 1.5 seconds
+        [2000], // 2 seconds
+        [60000], // 60 seconds
+    ])('resolves after %i milliseconds', async (delay) => {
+        let delay_value = delay[0];
+        const sleepPromise = sleep(delay_value);
+        jest.advanceTimersByTime(delay_value);
+        await sleepPromise;
+
+        // Allow a small margin of error for the timer
+        expect(setTimeout).toHaveBeenCalledWith(expect.any(Function), delay_value);
+    });
+
+    afterAll(() => {
+        jest.useRealTimers();
+    });
+});