unrounded stars

Author: leo60228

lib/content.js

@@ -1 +1,15 @@
-console.log('Hello, world!');
+import scanElement from './scanElement.js';
+
+async function observe(mutations) {
+    for (const mutation of mutations) {
+        for (const node of mutation.addedNodes) {
+            await scanElement(node);
+        }
+    }
+}
+
+const observer = new MutationObserver(observe);
+observer.observe(document.body, {
+    subtree: true,
+    childList: true
+});

lib/patches/unroundedStars.js

@@ -0,0 +1,36 @@
+import runOnPage from '../runOnPage.js';
+import { fiber, state, nth } from '../react.js';
+
+export default async function patch(stats) {
+    const bg = stats.closest('.Modal-Background');
+    const { player } = await runOnPage(async (bg, fiber, state, nth) => {
+        return state(nth(fiber(bg), 2));
+    })(bg, fiber, state, nth);
+    for (const line of stats.querySelectorAll('.Player-Info-Line')) {
+        const header = line.querySelector('.Player-Info-Line-Header').textContent;
+
+        const addRating = rating => {
+            const stars = rating * 5;
+            const rawStars = document.createElement('div');
+            rawStars.textContent = stars.toFixed(2);
+            rawStars.title = stars.toString();
+            line.style.gridTemplateColumns = '180px auto min-content';
+            line.append(rawStars);
+        };
+
+        switch (header) {
+            case 'Batting':
+                addRating(player.hittingRating);
+                break;
+            case 'Pitching':
+                addRating(player.pitchingRating);
+                break;
+            case 'Baserunning':
+                addRating(player.baserunningRating);
+                break;
+            case 'Defense':
+                addRating(player.defenseRating);
+                break;
+        }
+    }
+}

lib/react.js

@@ -0,0 +1,23 @@
+export function fiber(node) {
+    for (const key in node) {
+        if (key.startsWith('__reactInternalInstance$')) {
+            return node[key];
+        }
+    }
+}
+
+export function state(fiber) {
+    if (fiber.memoizedState.memoizedState) {
+        return fiber.memoizedState.memoizedState;
+    } else {
+        return fiber.memoizedState.baseQueue.eagerState;
+    }
+}
+
+export function nth(fiber, n) {
+    for (let i = 0; i < n; i++) {
+        fiber = fiber.return;
+    }
+
+    return fiber;
+}

lib/runOnPage.js

@@ -0,0 +1,73 @@
+import _ from 'lodash';
+
+const makeIdent = () => _.times(20, () => _.random(35).toString(36)).join('');
+
+export default function runOnPage(func) {
+    return (...args) => new Promise((resolve, reject) => {
+        const ident = makeIdent();
+
+        function onMessage(event) {
+            if (event.source !== window) return;
+
+            if (event.data.ident && event.data.ident === ident) {
+                window.removeEventListener('message', onMessage);
+                if ('ret' in event.data) {
+                    resolve(event.data.ret);
+                } else {
+                    reject(event.data.err);
+                }
+            }
+        }
+
+        const serializedArgs = args.map(x => {
+            if (x instanceof Element) {
+                if (x.id) {
+                    return { id: x.id };
+                } else {
+                    x.id = makeIdent();
+                    return { tempId: x.id };
+                }
+            } else if (typeof x === 'function') {
+                return { func: x.toString() };
+            } else {
+                return { val: x };
+            }
+        });
+
+        window.addEventListener('message', onMessage);
+
+        const serialized = func.toString();
+
+        const scriptContent = `
+        (async () => {
+            try {
+                const serializedArgs = ${JSON.stringify(serializedArgs)};
+                const args = serializedArgs.map(x => {
+                    if ('id' in x) {
+                        return document.getElementById(x.id);
+                    } else if ('tempId' in x) {
+                        const elem = document.getElementById(x.tempId);
+                        elem.id = '';
+                        return elem;
+                    } else if ('func' in x) {
+                        const generate = new Function('return ' + x.func);
+                        return generate();
+                    } else {
+                        return x.val;
+                    }
+                });
+                const ret = await (${serialized})(...args);
+                window.postMessage({ ident: ${JSON.stringify(ident)}, ret });
+            } catch (err) {
+                console.error(err);
+                window.postMessage({ ident: ${JSON.stringify(ident)}, err });
+            }
+        })();
+        document.currentScript.parentElement.removeChild(document.currentScript);
+        `;
+
+        const script = document.createElement('script');
+        script.innerHTML = scriptContent;
+        document.documentElement.prepend(script);
+    });
+}

lib/scanElement.js

@@ -0,0 +1,11 @@
+import unroundedStars from './patches/unroundedStars.js';
+
+export default async function scanElement(elem) {
+    if (!elem.classList || !elem.classList.contains) return;
+
+    if (elem.classList.contains('ModalItem-Content')) {
+        await Promise.all(Array.from(elem.children, x => scanElement(x)));
+    } else if (elem.classList.contains('Player-Info-Stats')) {
+        await unroundedStars(elem);
+    }
+}

package.json

@@ -22,6 +22,8 @@
         "webpack": "^5.23.0",
         "webpack-cli": "^4.5.0"
     },
-    "dependencies": {},
+    "dependencies": {
+        "lodash": "^4.17.20"
+    },
     "type": "module"
 }