commit 72f7874a1aecc6a54d948afb70d48c048b97c91f · indexx.dev/polyplus

+2 -2

entrypoints/home.content.ts

···

       50
        
               'favoritedPlaces',

     

       51
        
               async () => await api.batch('public', 'places/', places),

     

       52
        
               300000,

     

       53
       -
               true

     

       54
        
             );

     

       55
        
       

     

       56
        
             if (placeData == "disabled") {

     
···

       148
        
               'bestFriends',

     

       149
        
               async () => await api.batch('public', 'users/', friends),

     

       150
        
               300000,

     

       151
       -
               true

     

       152
        
             );

     

       153
        
       

     

       154
        
             if (userData == "disabled") {

···

       50
        
               'favoritedPlaces',

     

       51
        
               async () => await api.batch('public', 'places/', places),

     

       52
        
               300000,

     

       53
       +
               false

     

       54
        
             );

     

       55
        
       

     

       56
        
             if (placeData == "disabled") {

     
···

       148
        
               'bestFriends',

     

       149
        
               async () => await api.batch('public', 'users/', friends),

     

       150
        
               300000,

     

       151
       +
               false

     

       152
        
             );

     

       153
        
       

     

       154
        
             if (userData == "disabled") {

+37

entrypoints/profile.content/index.ts

···

       1
       +
       import { preferences } from "@/utils/storage";

     

       2
       +
       import config from "@/utils/config.json";

     

       3
       +
       import * as view from "./view";

     

       4
       +
       import { pullKVCache } from "@/utils/utilities";

     

       5
       +
       

     

       6
       +
       export default defineContentScript({

     

       7
       +
         matches: ['*://polytoria.com/u/*', '*://polytoria.com/users/*'],

     

       8
       +
         main() {

     

       9
       +
           preferences.getPreferences()

     

       10
       +
             .then(async (values) => {

     

       11
       +
               let userID;

     

       12
       +
               const username = window.location.pathname.split('/')[2];

     

       13
       +
               

     

       14
       +
               if (isNaN(username as any)) {

     

       15
       +
                 userID = await pullKVCache(

     

       16
       +
                   'userIDs',

     

       17
       +
                   username,

     

       18
       +
                   async () => {

     

       19
       +
                     if (!config.api.enabled) return "disabled";

     

       20
       +
         

     

       21
       +
                     const data = (await (await fetch(config.api.urls.public + "users/find?username=" + username)).json());

     

       22
       +
                     return data.id;

     

       23
       +
                   },

     

       24
       +
                   600000,

     

       25
       +
                   false

     

       26
       +
                 );

     

       27
       +
               } else {

     

       28
       +
                 userID = username; // * Fallback for legacy profile URLs

     

       29
       +
               }

     

       30
       +
       

     

       31
       +
               if (window.location.pathname.split('/')[1] == "u") {

     

       32
       +
                 // View

     

       33
       +
                 view.displayId(userID);

     

       34
       +
               };

     

       35
       +
             });

     

       36
       +
         }

     

       37
       +
       });

+43

entrypoints/profile.content/view.ts

···

       1
       +
       import config from "@/utils/config.json";

     

       2
       +
       

     

       3
       +
       export async function displayId(userId: number) {

     

       4
       +
           const statsCard = document.getElementById('user-stats-card');

     

       5
       +
           if (!statsCard) return; // ? Incase the user is blocked, which means the stats card won't be present

     

       6
       +
       

     

       7
       +
           const row = document.createElement('div');

     

       8
       +
           row.classList.add('mb-1');

     

       9
       +
           row.innerHTML = `

     

       10
       +
           <b>

     

       11
       +
               <i class="fa fa-hashtag text-center d-inline-block" style="width:1.3em"></i>

     

       12
       +
               Player ID

     

       13
       +
           </b>

     

       14
       +
           <span class="float-end">

     

       15
       +
               ${userId}

     

       16
       +
               <a id="copy" href="#copy">

     

       17
       +
                   <i class="fad fa-copy" style="margin-left: 5px;"></i>

     

       18
       +
               </a>

     

       19
       +
           </span>

     

       20
       +
           `;

     

       21
       +
       

     

       22
       +
           const copyBtn = row.getElementsByTagName('a')[0];

     

       23
       +
           copyBtn.addEventListener('click', () => {

     

       24
       +
               navigator.clipboard.writeText(userId as unknown as string)

     

       25
       +
                   .then(() => {

     

       26
       +
                       const icon: HTMLElement = copyBtn.children[0] as HTMLElement;

     

       27
       +
                       copyBtn.classList.add('text-success');

     

       28
       +
                       icon.setAttribute('class', 'fa-duotone fa-circle-check');

     

       29
       +
                       icon.style.marginLeft = '3px';

     

       30
       +
       

     

       31
       +
                       setTimeout(() => {

     

       32
       +
                           copyBtn.classList.remove('text-success');

     

       33
       +
                           icon.setAttribute('class', 'fad fa-copy');

     

       34
       +
                           icon.style.marginLeft = '5px';

     

       35
       +
                       }, 1500);

     

       36
       +
                   })

     

       37
       +
                   .catch(() => {

     

       38
       +
                       alert('Failure to copy user ID to clipboard.');

     

       39
       +
                   });

     

       40
       +
           });

     

       41
       +
       

     

       42
       +
           statsCard.children[0].insertBefore(row, statsCard.querySelector('.mb-1:has(.fa-calendar)')!);

     

       43
       +
       };

+2 -1

utils/storage.ts

···

       38
        
           fallback: {

     

       39
        
               favoritedPlaces: [],

     

       40
        
               bestFriends: [],

     

       41
       -
               inventory: []

     

       0
        
       
     

       42
        
           },

     

       43
        
           version: 1

     

       44
        
       });

···

       38
        
           fallback: {

     

       39
        
               favoritedPlaces: [],

     

       40
        
               bestFriends: [],

     

       41
       +
               inventory: [],

     

       42
       +
               userIDs: {}

     

       43
        
           },

     

       44
        
           version: 1

     

       45
        
       });

utils/types.ts

···

       0
        
       
     

       0
        
       
     

       1
        
       export type userDetails = {

     

       2
        
           username: string,

     

       3
        
           userId: number,

     
···

       9
        
           favoritedPlaces: never[],

     

       10
        
           bestFriends: never[],

     

       11
        
           inventory: never[],

     

       0
        
       
     

       12
        
           [key: string]: any;

     

       13
        
       };

     

       14

···

       1
       +
       import { avatarApiSchema } from "./api/types";

     

       2
       +
       

     

       3
        
       export type userDetails = {

     

       4
        
           username: string,

     

       5
        
           userId: number,

     
···

       11
        
           favoritedPlaces: never[],

     

       12
        
           bestFriends: never[],

     

       13
        
           inventory: never[],

     

       14
       +
           userIDs: Record<string, number>,

     

       15
        
           [key: string]: any;

     

       16
        
       };

     

       17

+103 -37

utils/utilities.ts

···

       1
        
       import config from "@/utils/config.json";

     

       2
        
       import { cache } from "./storage";

     

       3
       -
       import { avatarApiSchema, cacheInterface } from "./types";

     

       4
       -
       import * as currencyPackages from "./currencyPackages.json"

     

       0
        
       
     

       5
        
       

     

       6
       -
       export async function pullCache(key: string, replenish: Function, expiry: number, forceReplenish: boolean) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       7
        
           const cacheStorage: cacheInterface = await cache.getValue();

     

       8
       -
           const metadata = await cache.getMeta() as { [key: string]: number; };

     

       0
        
       
     

       9
        
       

     

       10
       -
           const overlap = Date.now() - metadata[key];

     

       11
       -
           if (!cacheStorage[key] || forceReplenish || (overlap >= expiry)) {

     

       12
       -
               console.info('[Poly+] "' + key + '" cache is stale replenishing...', timeAgo(overlap));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
       

     

       14
        
               const replenishedCache = await replenish();

     

       15
       -
               

     

       16
        
               // Don't cache the response when the config file has APIs disabled

     

       17
       -
               if (replenishedCache != "disabled") {

     

       18
        
                   cacheStorage[key] = replenishedCache;

     

       19
        
                   metadata[key] = Date.now();

     

       20
       -
                   

     

       21
       -
                   cache.setValue(cacheStorage);

     

       22
       -
                   cache.setMeta(metadata);

     

       23
        
               } else {

     

       24
        
                   return "disabled";

     

       25
       -
               };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       26
        
           };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       27
        
       

     

       28
       -
           return cacheStorage[key];

     

       29
       -
       };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       30
        
       

     

       31
        
       export async function expireCache(key: string) {

     

       32
        
           console.info('[Poly+] Forcefully expiring "' + key + '" cache...');

     

       33
       -
           

     

       34
        
           const metadata = await cache.getMeta() as { [key: string]: number };

     

       35
        
           metadata[key] = 0;

     

       36
        
           cache.setMeta(metadata);

     

       37
       -
       };

     

       38
        
       

     

       39
        
       function timeAgo(overlap: number) {

     

       40
        
           const units = [

     

       41
       -
               { label: 'day', value: 24 * 60 * 60 * 1000 },

     

       42
       -
               { label: 'hour', value: 60 * 60 * 1000 },

     

       43
       -
               { label: 'min', value: 60 * 1000 },

     

       44
       -
               { label: 'sec', value: 1000 },

     

       45
        
           ];

     

       46
        
       

     

       47
        
           for (const { label, value } of units) {

     

       48
        
               const count = Math.floor(overlap / value);

     

       49
        
               if (count > 0) {

     

       50
       -
                   return `${count} ${label}${count > 1 ? 's' : ''} ago`;

     

       51
        
               }

     

       52
        
               overlap %= value;

     

       53
        
           }

     

       54
        
       

     

       55
       -
           return 'just now';

     

       56
       -
       };

     

       57
        
       

     

       58
        
       export async function getUserDetails() {

     

       59
       -
           const profileLink: HTMLLinkElement = document.querySelector('.navbar a.text-reset[href^="/users/"]')!;

     

       60
       -
           const brickBalance = document.getElementsByClassName('brickBalanceCount')[0];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       61
        
       

     

       62
        
           if (!profileLink || !brickBalance) return null;

     

       63
        
       

     

       64
       -
           const userId = parseInt(profileLink.href.split('/')[4]);

     

       65
        
           return {

     

       66
        
               username: profileLink.innerText.trim(),

     

       67
        
               userId: userId,

     

       68
        
               bricks: parseInt(brickBalance.textContent!.replace(/,/g, "")),

     

       69
        
               getAvatar: async () => {

     

       70
        
                   if (config.api.enabled) {

     

       71
       -
                       const avatar = (await (await fetch(config.api.urls.public + 'users/' + userId + '/avatar')).json());

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       72
        
                       return avatar as avatarApiSchema;

     

       73
        
                   } else {

     

       74
        
                       return "disabled";

     

       75
       -
                   };

     

       76
       -
               }

     

       77
       -
           }

     

       78
       -
       };

     

       79
        
       

     

       80
       -
       export function bricksToCurrency(bricks: number, currency: string): string | null {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       81
        
           if (isNaN(bricks) || bricks == 0) return null;

     

       82
        
       

     

       83
       -
           const _currencyPackages = currencyPackages as Record<string, Array<Array<number>>>;

     

       84
       -
           const packages = _currencyPackages[currency].toSorted((a, b) => b[1] - a[1]);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       85
        
       

     

       86
        
           if (!packages) {

     

       87
       -
               console.warn('[Poly+] Missing currency package data for selected currency!');

     

       0
        
       
     

       0
        
       
     

       88
        
               return null;

     

       89
        
           }

     

       90
        
       

     
···

       104
        
           }

     

       105
        
       

     

       106
        
           return `~${totalValue.toFixed(2)} ${currency}`;

     

       107
       -
       };

···

       1
        
       import config from "@/utils/config.json";

     

       2
        
       import { cache } from "./storage";

     

       3
       +
       import { cacheInterface } from "./types";

     

       4
       +
       import { avatarApiSchema } from "./api/types";

     

       5
       +
       import * as currencyPackages from "./currencyPackages.json";

     

       6
        
       

     

       7
       +
       export async function pullCache(

     

       8
       +
           key: string,

     

       9
       +
           replenish: Function,

     

       10
       +
           expiry: number,

     

       11
       +
           forceReplenish: boolean,

     

       12
       +
       ) {

     

       13
        
           const cacheStorage: cacheInterface = await cache.getValue();

     

       14
       +
           const metadata = (await cache.getMeta()) as { [key: string]: number };

     

       15
       +
           const overlap = Date.now() - (metadata[key] || 0);

     

       16
        
       

     

       17
       +
           if (

     

       18
       +
               !cacheStorage[key] || !metadata[key] || forceReplenish ||

     

       19
       +
               overlap >= expiry

     

       20
       +
           ) {

     

       21
       +
               console.info(

     

       22
       +
                   `[Poly+] "${key}" cache is stale replenishing...`,

     

       23
       +
                   timeAgo(overlap),

     

       24
       +
               );

     

       25
        
       

     

       26
        
               const replenishedCache = await replenish();

     

       27
       +
       

     

       28
        
               // Don't cache the response when the config file has APIs disabled

     

       29
       +
               if (replenishedCache !== "disabled") {

     

       30
        
                   cacheStorage[key] = replenishedCache;

     

       31
        
                   metadata[key] = Date.now();

     

       32
       +
                   await cache.setValue(cacheStorage);

     

       33
       +
                   await cache.setMeta(metadata);

     

       0
        
       
     

       34
        
               } else {

     

       35
        
                   return "disabled";

     

       36
       +
               }

     

       37
       +
           }

     

       38
       +
       

     

       39
       +
           return cacheStorage[key];

     

       40
       +
       }

     

       41
       +
       

     

       42
       +
       export async function pullKVCache(

     

       43
       +
           store: string,

     

       44
       +
           key: string,

     

       45
       +
           replenish: Function,

     

       46
       +
           expiry: number,

     

       47
       +
           forceReplenish: boolean,

     

       48
       +
       ) {

     

       49
       +
           const cacheStorage: cacheInterface = await cache.getValue();

     

       50
       +
           const metadata = (await cache.getMeta()) as {

     

       51
       +
               [key: string]: Record<string, number>;

     

       52
        
           };

     

       53
       +
           

     

       54
       +
           if (!cacheStorage[store]) cacheStorage[store] = {};

     

       55
       +
           if (!metadata[store]) metadata[store] = {};

     

       56
        
       

     

       57
       +
           const overlap = Date.now() - (metadata[store][key] || 0);

     

       58
       +
       

     

       59
       +
           if (!cacheStorage[store][key] || forceReplenish || overlap >= expiry) {

     

       60
       +
               console.info(

     

       61
       +
                   `[Poly+] "${key}" KV cache is stale replenishing...`,

     

       62
       +
                   timeAgo(overlap),

     

       63
       +
               );

     

       64
       +
       

     

       65
       +
               const replenishedCache = await replenish();

     

       66
       +
       

     

       67
       +
               // Don't cache the response when the config file has APIs disabled

     

       68
       +
               if (replenishedCache !== "disabled") {

     

       69
       +
                   cacheStorage[store][key] = replenishedCache;

     

       70
       +
                   metadata[store][key] = Date.now();

     

       71
       +
                   await cache.setValue(cacheStorage);

     

       72
       +
                   await cache.setMeta(metadata);

     

       73
       +
               } else {

     

       74
       +
                   return "disabled";

     

       75
       +
               }

     

       76
       +
           }

     

       77
       +
       

     

       78
       +
           return cacheStorage[store][key];

     

       79
       +
       }

     

       80
        
       

     

       81
        
       export async function expireCache(key: string) {

     

       82
        
           console.info('[Poly+] Forcefully expiring "' + key + '" cache...');

     

       83
       +
       

     

       84
        
           const metadata = await cache.getMeta() as { [key: string]: number };

     

       85
        
           metadata[key] = 0;

     

       86
        
           cache.setMeta(metadata);

     

       87
       +
       }

     

       88
        
       

     

       89
        
       function timeAgo(overlap: number) {

     

       90
        
           const units = [

     

       91
       +
               { label: "day", value: 24 * 60 * 60 * 1000 },

     

       92
       +
               { label: "hour", value: 60 * 60 * 1000 },

     

       93
       +
               { label: "min", value: 60 * 1000 },

     

       94
       +
               { label: "sec", value: 1000 },

     

       95
        
           ];

     

       96
        
       

     

       97
        
           for (const { label, value } of units) {

     

       98
        
               const count = Math.floor(overlap / value);

     

       99
        
               if (count > 0) {

     

       100
       +
                   return `${count} ${label}${count > 1 ? "s" : ""} ago`;

     

       101
        
               }

     

       102
        
               overlap %= value;

     

       103
        
           }

     

       104
        
       

     

       105
       +
           return "just now";

     

       106
       +
       }

     

       107
        
       

     

       108
        
       export async function getUserDetails() {

     

       109
       +
           const profileLink: HTMLLinkElement = document.querySelector(

     

       110
       +
               '.navbar a.text-reset[href^="/users/"]',

     

       111
       +
           )!;

     

       112
       +
           const brickBalance =

     

       113
       +
               document.getElementsByClassName("brickBalanceCount")[0];

     

       114
        
       

     

       115
        
           if (!profileLink || !brickBalance) return null;

     

       116
        
       

     

       117
       +
           const userId = parseInt(profileLink.href.split("/")[4]);

     

       118
        
           return {

     

       119
        
               username: profileLink.innerText.trim(),

     

       120
        
               userId: userId,

     

       121
        
               bricks: parseInt(brickBalance.textContent!.replace(/,/g, "")),

     

       122
        
               getAvatar: async () => {

     

       123
        
                   if (config.api.enabled) {

     

       124
       +
                       const avatar =

     

       125
       +
                           await (await fetch(

     

       126
       +
                               config.api.urls.public + "users/" + userId + "/avatar",

     

       127
       +
                           )).json();

     

       128
        
                       return avatar as avatarApiSchema;

     

       129
        
                   } else {

     

       130
        
                       return "disabled";

     

       131
       +
                   }

     

       132
       +
               },

     

       133
       +
           };

     

       134
       +
       }

     

       135
        
       

     

       136
       +
       export function bricksToCurrency(

     

       137
       +
           bricks: number,

     

       138
       +
           currency: string,

     

       139
       +
       ): string | null {

     

       140
        
           if (isNaN(bricks) || bricks == 0) return null;

     

       141
        
       

     

       142
       +
           const _currencyPackages = currencyPackages as Record<

     

       143
       +
               string,

     

       144
       +
               Array<Array<number>>

     

       145
       +
           >;

     

       146
       +
           const packages = _currencyPackages[currency].toSorted((a, b) =>

     

       147
       +
               b[1] - a[1]

     

       148
       +
           );

     

       149
        
       

     

       150
        
           if (!packages) {

     

       151
       +
               console.warn(

     

       152
       +
                   "[Poly+] Missing currency package data for selected currency!",

     

       153
       +
               );

     

       154
        
               return null;

     

       155
        
           }

     

       156
        
       

     
···

       170
        
           }

     

       171
        
       

     

       172
        
           return `~${totalValue.toFixed(2)} ${currency}`;

     

       173
       +
       }