perfectionist-plugins 2.0.0 → 2.4.0

package/unlock-profile-skins.js

@@ -1,4 +1,4 @@
-export const version = "1.2.1";
+export const version = "1.2.4";
 
 const PLUGIN_ID = "unlock-profile-skins";
 const PICKER_BUTTON_SELECTOR = ".style-profile-skin-picker-button";
@@ -6,12 +6,14 @@ const CURRENT_SUMMONER_URI = "/lol-summoner/v1/current-summoner";
 const INVENTORY_PATH = /^\/lol-champions\/v1\/inventories\/(\d+)\/champions$/;
 const AUGMENT_INVENTORY_PATH = /^\/lol-inventory\/v2\/inventory\/SKIN_AUGMENT$/i;
 const SUMMONER_TTL = 10 * 60 * 1000;
+const SUMMONER_WAIT_MS = 1200;
 const STATE_KEY = "perfectionist-plugins:state";
 const FAKE_PURCHASE_DATE = 1577836800000;
 const FAKE_RENTAL_END = 4102444800000;
 const TIER_LABEL = "tier";
 const GROUPING_OPTIONS = "lol-uikit-dropdown-option";
 const HARVEST_WAIT_MS = 2000;
+const INVENTORY_TEXT_CACHE_LIMIT = 2;
 
 let filterActive = true;
 let api = null;
@@ -22,6 +24,7 @@ let harvestPromise = null;
 const augmentIds = new Set();
 const pendingTargetLoads = new Set();
 const variantIdRemap = new Map();
+const inventoryTextCache = new Map();
 
 function readDefaultEnabled() {
   try {
@@ -196,17 +199,24 @@ function unlockDeep(node) {
       }
     }
   }
-  if (node.ownership && typeof node.ownership === "object") {
-    changed = unlockOwnership(node.ownership) || changed;
-  } else if (typeof node.contentId === "string" && Array.isArray(node.overlays)) {
-    node.ownership = synthesizedOwnership();
-    changed = true;
-  }
-  if (node.owned === false) {
-    node.owned = true;
-    changed = true;
+  const championNode = Array.isArray(node.skins);
+  if (!championNode) {
+    if (node.ownership && typeof node.ownership === "object") {
+      changed = unlockOwnership(node.ownership) || changed;
+    } else if (typeof node.contentId === "string" && Array.isArray(node.overlays)) {
+      node.ownership = synthesizedOwnership();
+      changed = true;
+    }
+    if (node.owned === false) {
+      node.owned = true;
+      changed = true;
+    }
   }
-  const values = Array.isArray(node) ? node : Object.values(node);
+  const values = Array.isArray(node)
+    ? node
+    : Object.keys(node)
+        .filter((key) => key !== "ownership")
+        .map((key) => node[key]);
   for (const value of values) {
     if (value && typeof value === "object") changed = unlockDeep(value) || changed;
   }
@@ -279,6 +289,7 @@ function ensureAugmentIds() {
 let tierObserver = null;
 let tierAppliedForOpen = false;
 let tierDropdown = null;
+let tierArmListener = null;
 
 function findGroupingDropdown() {
   for (const dd of document.querySelectorAll("lol-uikit-framed-dropdown")) {
@@ -312,6 +323,10 @@ function applyTierGrouping() {
 function startTierGrouping() {
   if (tierObserver) return;
   tierObserver = new MutationObserver(() => {
+    if (!isPickerOpen()) {
+      stopTierGrouping();
+      return;
+    }
     try {
       applyTierGrouping();
     } catch (error) {
@@ -334,12 +349,34 @@ function maybeRefreshSummoner() {
   ensureSummonerId();
 }
 
+function whenSummonerKnown(timeout) {
+  if (summonerId !== null) return Promise.resolve(true);
+  ensureSummonerId();
+  const deadline = Date.now() + timeout;
+  return new Promise((resolve) => {
+    const step = () => {
+      if (summonerId !== null) return resolve(true);
+      if (Date.now() >= deadline) return resolve(false);
+      setTimeout(step, 40);
+    };
+    setTimeout(step, 0);
+  });
+}
+
 function ensureSummonerId() {
   if (summonerId !== null || summonerPending) return;
-  const get = api?.lcu?.get;
-  if (!get) return;
   summonerPending = true;
-  get(CURRENT_SUMMONER_URI, { ttl: SUMMONER_TTL })
+  let request;
+  try {
+    const get = api?.lcu?.get;
+    request = get
+      ? get(CURRENT_SUMMONER_URI, { ttl: SUMMONER_TTL })
+      : (rawFetch || window.fetch)(CURRENT_SUMMONER_URI).then((response) => response.json());
+  } catch {
+    summonerPending = false;
+    return;
+  }
+  Promise.resolve(request)
     .then((summoner) => {
       summonerId = typeof summoner?.summonerId === "number" ? summoner.summonerId : null;
     })
@@ -348,13 +385,31 @@ function ensureSummonerId() {
       summonerPending = false;
     });
 }
+function rewriteInventoryText(raw) {
+  if (typeof raw !== "string") return raw;
+  if (inventoryTextCache.has(raw)) {
+    const cached = inventoryTextCache.get(raw);
+    inventoryTextCache.delete(raw);
+    inventoryTextCache.set(raw, cached);
+    return cached;
+  }
+  let rewritten = raw;
+  try {
+    const json = JSON.parse(raw);
+    if (unlockDeep(json)) rewritten = JSON.stringify(json);
+  } catch {}
+  inventoryTextCache.set(raw, rewritten);
+  while (inventoryTextCache.size > INVENTORY_TEXT_CACHE_LIMIT) {
+    inventoryTextCache.delete(inventoryTextCache.keys().next().value);
+  }
+  return rewritten;
+}
 
 function rewriteWebSocketFrame(text) {
   if (!filterActive || typeof text !== "string") return null;
   const targetFrame = text.indexOf("lol-champions/v1/inventories") !== -1;
   const augmentFrame = text.indexOf("SKIN_AUGMENT") !== -1;
   if (!targetFrame && !augmentFrame) return null;
-  if (!isPickerOpen()) return null;
   let frame;
   try {
     frame = JSON.parse(text);
@@ -454,53 +509,72 @@ function installFetchFilter() {
 
   const wrapped = function (input, init) {
     const url = typeof input === "string" ? input : (input && input.url) || "";
-    const target = isTargetUrl(url);
-    const augment = !target && isAugmentUrl(url);
-    if (filterActive && pathIdOf(url) !== null) maybeRefreshSummoner();
-    if (filterActive && init && typeof init.body === "string") {
-      const mapped = remapVariantIds(init.body);
-      if (mapped !== init.body) init = { ...init, body: mapped };
+    const inventory = pathIdOf(url) !== null;
+    const augmentRequest = isAugmentUrl(url);
+    let options = init;
+    if (filterActive && options && typeof options.body === "string") {
+      const mapped = remapVariantIds(options.body);
+      if (mapped !== options.body) options = { ...options, body: mapped };
     }
-    const promise = original.call(this, input, init);
-    if (filterActive && target && augmentIds.size === 0) {
-      const latch = (async () => {
-        try {
-          const response = await promise;
-          if (response && response.ok && augmentIds.size === 0) {
-            const json = await response.clone().json().catch(() => null);
-            if (json) harvestFromPayload(json);
+    const promise = original.call(this, input, options);
+    if (!filterActive || (!inventory && !augmentRequest)) return promise;
+    if (inventory) maybeRefreshSummoner();
+
+    return whenSummonerKnown(SUMMONER_WAIT_MS).then(() => {
+      const target = isTargetUrl(url);
+      if (!augmentRequest && !target) return promise;
+      if (target && augmentIds.size === 0) {
+        const latch = (async () => {
+          try {
+            const response = await promise;
+            if (response && response.ok && augmentIds.size === 0) {
+              const json = await response.clone().json().catch(() => null);
+              if (json) harvestFromPayload(json);
+            }
+          } catch {}
+          pendingTargetLoads.delete(latch);
+        })();
+        pendingTargetLoads.add(latch);
+      }
+      const ready = augmentRequest && augmentIds.size === 0 ? ensureAugmentIds() : Promise.resolve();
+      return ready
+        .then(() => promise)
+        .then((response) => {
+          if (!response || !response.ok) return response;
+          if (augmentRequest) {
+            return response
+              .clone()
+              .json()
+              .catch(() => null)
+              .then((json) => {
+                if (!json || !unlockAugmentInventory(json)) return response;
+                return new Response(JSON.stringify(json), {
+                  status: response.status,
+                  statusText: response.statusText,
+                  headers: response.headers,
+                });
+              });
           }
-        } catch {}
-        pendingTargetLoads.delete(latch);
-      })();
-      pendingTargetLoads.add(latch);
-    }
-    if (!filterActive || (!target && !augment) || !isPickerOpen()) return promise;
-    const ready = augment && augmentIds.size === 0 ? ensureAugmentIds() : Promise.resolve();
-    return ready
-      .then(() => promise)
-      .then((response) => {
-        if (!response || !response.ok) return response;
-        return response
-          .clone()
-          .json()
-          .catch(() => null)
-          .then((json) => {
-            if (!json) return response;
-            const changed = augment ? unlockAugmentInventory(json) : unlockDeep(json);
-            if (!changed) return response;
-            return new Response(JSON.stringify(json), {
-              status: response.status,
-              statusText: response.statusText,
-              headers: response.headers,
+          return response
+            .clone()
+            .text()
+            .catch(() => null)
+            .then((text) => {
+              if (text === null) return response;
+              const rewritten = rewriteInventoryText(text);
+              if (rewritten === text) return response;
+              return new Response(rewritten, {
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+              });
             });
-          });
-      });
+        });
+    });
   };
   wrapped.__perfProfileFilter = true;
   window.fetch = wrapped;
 }
-
 function installXhrFilter() {
   const proto = window.XMLHttpRequest && window.XMLHttpRequest.prototype;
   if (!proto || proto.open.__perfProfileFilter) return;
@@ -543,23 +617,24 @@ function installXhrFilter() {
       });
       pendingTargetLoads.add(latch);
     }
-    if (textDescriptor && textDescriptor.get && (target || augment)) {
+    if (textDescriptor && textDescriptor.get && (pathIdOf(url) !== null || augment)) {
       const cache = { raw: null, gate: null, filtered: null };
-      const gateOpen = () => filterActive && isPickerOpen();
+      const gateOpen = () => filterActive && (augment || isTargetUrl(url));
       const rewriteBody = (json) => (augment ? unlockAugmentInventory(json) : unlockDeep(json));
       const filteredText = () => {
-        const raw = textDescriptor.get.call(xhr);
         const gate = gateOpen();
-        if (cache.filtered === null || cache.raw !== raw || cache.gate !== gate) {
-          cache.raw = raw;
-          cache.gate = gate;
-          cache.filtered = raw;
-          if (gate) {
+        if (cache.filtered !== null && cache.gate === gate) return cache.filtered;
+        const raw = textDescriptor.get.call(xhr);
+        cache.gate = gate;
+        cache.filtered = raw;
+        if (gate) {
+          if (augment) {
             try {
               const json = JSON.parse(raw);
-              const rewritten = rewriteBody(json) ? JSON.stringify(json) : null;
-              if (rewritten !== null) cache.filtered = rewritten;
+              if (rewriteBody(json)) cache.filtered = JSON.stringify(json);
             } catch {}
+          } else {
+            cache.filtered = rewriteInventoryText(raw);
           }
         }
         return cache.filtered;
@@ -578,7 +653,7 @@ function installXhrFilter() {
         });
       }
     }
-    if (augment && filterActive && isPickerOpen() && augmentIds.size === 0) {
+    if (augment && filterActive && augmentIds.size === 0) {
       const sendArgs = args;
       ensureAugmentIds().finally(() => {
         try {
@@ -597,6 +672,7 @@ function installSourceFilter() {
     installWebSocketFilter();
     installFetchFilter();
     installXhrFilter();
+    ensureSummonerId();
   } catch (error) {
     logError("could not install the source filter.", error);
   }
@@ -617,11 +693,21 @@ function onEnable(utils) {
   filterActive = true;
   ensureSourceFilter();
   ensureSummonerId();
-  startTierGrouping();
+  tierArmListener = () => {
+    if (tierObserver) return;
+    setTimeout(() => {
+      if (tierArmListener && isPickerOpen()) startTierGrouping();
+    }, 0);
+  };
+  document.addEventListener("click", tierArmListener, true);
+  if (isPickerOpen()) startTierGrouping();
 }
 
 function onDisable() {
   filterActive = false;
+  inventoryTextCache.clear();
+  if (tierArmListener) document.removeEventListener("click", tierArmListener, true);
+  tierArmListener = null;
   stopTierGrouping();
   api = null;
 }

package/tools/betterclient-monitor.js

@@ -1,269 +0,0 @@
-#!/usr/bin/env node
-// BetterClient memory monitor.
-//
-// Samples every League/Riot process once per interval, records client phase
-// (read straight from the LCU with the running client's own credentials) and
-// writes a CSV you can chart. With --diff it compares two V8 heap snapshots and
-// prints the constructors that grew the most.
-//
-//   node tools/betterclient-monitor.mjs                     # live table + CSV
-//   node tools/betterclient-monitor.mjs --minutes 240       # long session
-//   node tools/betterclient-monitor.mjs --snapshots 15      # heap snapshots via CDP
-//   node tools/betterclient-monitor.mjs --diff a.heapsnapshot b.heapsnapshot
-//
-// Nothing is installed and nothing is written outside --out / --snapshot-dir.
-
-import { execFileSync } from "node:child_process";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import https from "node:https";
-
-const args = process.argv.slice(2);
-const flag = (name, fallback) => {
-  const index = args.indexOf(`--${name}`);
-  if (index === -1) return fallback;
-  const value = args[index + 1];
-  return value && !value.startsWith("--") ? value : true;
-};
-
-const diffFiles = args.filter((entry) => entry.endsWith(".heapsnapshot"));
-if (args.includes("--diff")) {
-  diffSnapshots(diffFiles[0], diffFiles[1]);
-  process.exit(0);
-}
-
-const intervalSec = Number(flag("interval", 5));
-const minutes = Number(flag("minutes", 0));
-const out = String(flag("out", "betterclient-monitor.csv"));
-const snapshotEvery = Number(flag("snapshots", 0));
-const snapshotDir = String(flag("snapshot-dir", "heapsnapshots"));
-const snapshotPrefix = String(flag("prefix", "betterclient"));
-
-const NAMES = ["LeagueClient", "LeagueClientUx", "LeagueClientUxRender", "RiotClientServices", "RiotClientCrashHandler"];
-
-function powershell(script) {
-  return execFileSync("powershell", ["-NoProfile", "-Command", script], { encoding: "utf8", windowsHide: true });
-}
-
-function sampleProcesses() {
-  const filter = NAMES.map((name) => `$_.ProcessName -eq '${name}'`).join(" -or ");
-  const script = `Get-Process -ErrorAction SilentlyContinue | Where-Object { ${filter} } | ForEach-Object { "$($_.ProcessName)|$($_.Id)|$($_.WorkingSet64)|$($_.PrivateMemorySize64)|$($_.TotalProcessorTime.TotalSeconds)" }`;
-  const rows = powershell(script)
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .map((line) => {
-      const [name, pid, workingSet, priv, cpu] = line.split("|");
-      return { name, pid: Number(pid), mb: Math.round(Number(workingSet) / 1048576), privateMb: Math.round(Number(priv) / 1048576), cpu: Number(cpu) };
-    });
-  return rows.sort((a, b) => a.pid - b.pid);
-}
-
-let lcu = null;
-function discoverLcu() {
-  if (lcu) return lcu;
-  try {
-    const commandLine = powershell(`(Get-CimInstance Win32_Process -Filter "Name='LeagueClientUx.exe'").CommandLine`);
-    const port = /"?"--app-port=(\d+)/.exec(commandLine)?.[1];
-    const token = /"?"--remoting-auth-token=([\w-]+)/.exec(commandLine)?.[1];
-    if (port && token) lcu = { port: Number(port), token };
-  } catch {}
-  return lcu;
-}
-
-function lcuGet(path) {
-  const auth = discoverLcu();
-  if (!auth) return Promise.resolve(null);
-  return new Promise((resolve) => {
-    const request = https.request(
-      {
-        host: "127.0.0.1",
-        port: auth.port,
-        path,
-        method: "GET",
-        rejectUnauthorized: false,
-        headers: { Authorization: `Basic ${Buffer.from(`riot:${auth.token}`).toString("base64")}`, Accept: "application/json" },
-        timeout: 4000,
-      },
-      (response) => {
-        let body = "";
-        response.on("data", (chunk) => (body += chunk));
-        response.on("end", () => {
-          try {
-            resolve(JSON.parse(body));
-          } catch {
-            resolve(body);
-          }
-        });
-      },
-    );
-    request.on("error", () => resolve(null));
-    request.on("timeout", () => {
-      request.destroy();
-      resolve(null);
-    });
-    request.end();
-  });
-}
-
-async function cdpTarget() {
-  for (const port of [9222, 9223, 9229, 9333]) {
-    try {
-      const response = await fetch(`http://127.0.0.1:${port}/json/list`, { signal: AbortSignal.timeout(1500) });
-      if (!response.ok) continue;
-      const targets = await response.json();
-      const page = targets.find((t) => t.webSocketDebuggerUrl && /league|client|riot/i.test(t.url ?? "")) ?? targets.find((t) => t.webSocketDebuggerUrl);
-      if (page) return page.webSocketDebuggerUrl;
-    } catch {}
-  }
-  return null;
-}
-
-async function takeHeapSnapshot() {
-  const url = await cdpTarget();
-  if (!url) {
-    console.log("[snapshot] no CDP endpoint found - start the client with a remote debugging port to record heap snapshots");
-    return null;
-  }
-  if (!existsSync(snapshotDir)) mkdirSync(snapshotDir, { recursive: true });
-  const name = `${snapshotDir}/${snapshotPrefix}-${new Date().toISOString().replace(/[:.]/g, "-")}.heapsnapshot`;
-  const socket = new WebSocket(url);
-  const chunks = [];
-  let id = 0;
-  const send = (method, params = {}) => socket.send(JSON.stringify({ id: ++id, method, params }));
-  await new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error("snapshot timed out")), 180000);
-    socket.addEventListener("open", () => {
-      send("HeapProfiler.enable");
-      send("HeapProfiler.collectGarbage");
-      send("HeapProfiler.takeHeapSnapshot", { reportProgress: false, captureNumericValue: false });
-    });
-    socket.addEventListener("message", (event) => {
-      const message = JSON.parse(event.data);
-      if (message.method === "HeapProfiler.addHeapSnapshotChunk") chunks.push(message.params.chunk);
-      if (message.id === id) {
-        clearTimeout(timer);
-        if (message.error) reject(new Error(message.error.message));
-        else resolve();
-      }
-    });
-    socket.addEventListener("error", (error) => {
-      clearTimeout(timer);
-      reject(error);
-    });
-  }).finally(() => socket.close());
-  writeFileSync(name, chunks.join(""));
-  console.log(`[snapshot] wrote ${name} (${(chunks.join("").length / 1048576).toFixed(1)} MB)`);
-  return name;
-}
-
-function diffSnapshots(fromPath, toPath) {
-  if (!fromPath || !toPath) {
-    console.log("usage: node tools/betterclient-monitor.mjs --diff old.heapsnapshot new.heapsnapshot");
-    return;
-  }
-  for (const path of [fromPath, toPath]) {
-    if (!existsSync(path)) {
-      console.log(`missing file: ${path}`);
-      return;
-    }
-  }
-  const tally = (snapshot) => {
-    const nodeFields = snapshot.snapshot.meta.node_fields;
-    const nodeTypes = snapshot.snapshot.meta.node_types[nodeFields.indexOf("type")];
-    const nameOffset = nodeFields.indexOf("name");
-    const sizeOffset = nodeFields.indexOf("self_size");
-    const width = nodeFields.length;
-    const nodes = snapshot.nodes;
-    const strings = snapshot.strings;
-    const map = new Map();
-    for (let i = 0; i < nodes.length; i += width) {
-      const type = nodeTypes[nodes[i]];
-      const name = strings[nodes[i + nameOffset]] ?? type;
-      const key = `${type}:${name}`;
-      const entry = map.get(key) ?? { count: 0, bytes: 0 };
-      entry.count += 1;
-      entry.bytes += nodes[i + sizeOffset];
-      map.set(key, entry);
-    }
-    return map;
-  };
-  const before = tally(JSON.parse(readFileSync(fromPath, "utf8")));
-  const after = tally(JSON.parse(readFileSync(toPath, "utf8")));
-  const rows = [];
-  for (const [key, value] of after) {
-    const previous = before.get(key) ?? { count: 0, bytes: 0 };
-    rows.push({ key, count: value.count - previous.count, bytes: value.bytes - previous.bytes });
-  }
-  rows.sort((a, b) => b.bytes - a.bytes);
-  console.log(`\ntop growers between the two snapshots:`);
-  for (const row of rows.slice(0, 25)) {
-    if (row.bytes <= 0) break;
-    console.log(`  +${(row.bytes / 1048576).toFixed(2)} MB  ${String(row.count).padStart(7)} nodes  ${row.key}`);
-  }
-  const total = rows.reduce((sum, row) => sum + row.bytes, 0);
-  console.log(`\nnet ${(total / 1048576).toFixed(1)} MB`);
-}
-
-const started = Date.now();
-const history = new Map();
-writeFileSync(out, "timestamp,phase,pid,process,working_set_mb,private_mb,cpu_seconds,cpu_percent\n");
-console.log(`writing ${out} - every ${intervalSec}s${minutes ? ` for ${minutes} min` : " until Ctrl+C"}`);
-
-const lastCpu = new Map();
-let lastCpuAt = Date.now();
-let tick = 0;
-
-async function loop() {
-  tick += 1;
-  let phase = "?";
-  try {
-    phase = await lcuGet("/lol-gameflow/v1/gameflow-phase");
-  } catch {}
-  const rows = sampleProcesses();
-  const now = Date.now();
-  const elapsed = (now - lastCpuAt) / 1000;
-  const parts = [];
-  for (const row of rows) {
-    const previous = lastCpu.get(row.pid);
-    const cpuPercent = previous !== undefined && elapsed > 0 ? Math.max(0, ((row.cpu - previous) / elapsed) * 100) : 0;
-    lastCpu.set(row.pid, row.cpu);
-    appendFileSync(out, `${new Date(now).toISOString()},${phase},${row.pid},${row.name},${row.mb},${row.privateMb},${row.cpu.toFixed(1)},${cpuPercent.toFixed(1)}\n`);
-    parts.push(`${row.name.replace("LeagueClient", "LC")}#${row.pid} ${row.mb}MB ${cpuPercent.toFixed(0)}%`);
-    const series = history.get(row.pid) ?? [];
-    series.push(row.mb);
-    history.set(row.pid, series);
-  }
-  lastCpuAt = now;
-  const totalMb = rows.reduce((sum, row) => sum + row.mb, 0);
-  console.log(`[${new Date(now).toLocaleTimeString()}] phase=${phase} total=${totalMb}MB | ${parts.join(" | ")}`);
-
-  if (snapshotEvery > 0 && tick % Math.max(1, Math.round((snapshotEvery * 60) / intervalSec)) === 0) {
-    await takeHeapSnapshot().catch((error) => console.log(`[snapshot] failed: ${error.message}`));
-  }
-
-  if (minutes > 0 && now - started >= minutes * 60 * 1000) {
-    console.log("\ngrowth over the run:");
-    for (const [pid, series] of history) {
-      if (series.length < 2) continue;
-      const first = series[0];
-      const last = series[series.length - 1];
-      const delta = last - first;
-      const minutesRun = Math.max(0.1, (Date.now() - started) / 60000);
-      const perHour = (delta / minutesRun) * 60;
-      const row = rows.find((entry) => entry.pid === pid);
-      console.log(`  ${row?.name ?? "process"}#${pid}: ${first}MB -> ${last}MB (${delta >= 0 ? "+" : ""}${delta}MB, ${perHour >= 0 ? "+" : ""}${perHour.toFixed(0)}MB/h)`);
-      if (perHour > 200) console.log("    ^ leak candidate - this process alone keeps growing");
-    }
-    console.log(`\nfull series in ${out}`);
-    process.exit(0);
-  }
-}
-
-while (true) {
-  try {
-    await loop();
-  } catch (error) {
-    console.log(`sample failed: ${error.message}`);
-  }
-  await new Promise((resolve) => setTimeout(resolve, intervalSec * 1000));
-}